@plures/praxis 1.2.12 → 1.2.41

package/dist/node/cli/index.cjs

@@ -3517,9 +3517,9 @@ var init_cloud = __esm({
   }
 });
 
-// node_modules/typescript/lib/typescript.js
+// node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS({
-  "node_modules/typescript/lib/typescript.js"(exports2, module2) {
+  "node_modules/.pnpm/typescript@5.9.3/node_modules/typescript/lib/typescript.js"(exports2, module2) {
     "use strict";
     var ts2 = {};
     ((module3) => {
@@ -7174,10 +7174,10 @@ var require_typescript = __commonJS({
       function and(f, g) {
         return (arg) => f(arg) && g(arg);
       }
-      function or(...fs12) {
+      function or(...fs14) {
         return (...args) => {
           let lastResult;
-          for (const f of fs12) {
+          for (const f of fs14) {
             lastResult = f(...args);
             if (lastResult) {
               return lastResult;
@@ -8752,7 +8752,7 @@ ${lanes.join("\n")}
       var tracing;
       var tracingEnabled;
       ((tracingEnabled2) => {
-        let fs12;
+        let fs14;
         let traceCount = 0;
         let traceFd = 0;
         let mode;
@@ -8761,9 +8761,9 @@ ${lanes.join("\n")}
         const legend = [];
         function startTracing2(tracingMode, traceDir, configFilePath) {
           Debug.assert(!tracing, "Tracing already started");
-          if (fs12 === void 0) {
+          if (fs14 === void 0) {
             try {
-              fs12 = require("fs");
+              fs14 = require("fs");
             } catch (e) {
               throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -8774,8 +8774,8 @@ ${lanes.join("\n")}
           if (legendPath === void 0) {
             legendPath = combinePaths(traceDir, "legend.json");
           }
-          if (!fs12.existsSync(traceDir)) {
-            fs12.mkdirSync(traceDir, { recursive: true });
+          if (!fs14.existsSync(traceDir)) {
+            fs14.mkdirSync(traceDir, { recursive: true });
           }
           const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
           const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -8785,10 +8785,10 @@ ${lanes.join("\n")}
             tracePath,
             typesPath
           });
-          traceFd = fs12.openSync(tracePath, "w");
+          traceFd = fs14.openSync(tracePath, "w");
           tracing = tracingEnabled2;
           const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
-          fs12.writeSync(
+          fs14.writeSync(
             traceFd,
             "[\n" + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(",\n")
           );
@@ -8797,10 +8797,10 @@ ${lanes.join("\n")}
         function stopTracing() {
           Debug.assert(tracing, "Tracing is not in progress");
           Debug.assert(!!typeCatalog.length === (mode !== "server"));
-          fs12.writeSync(traceFd, `
+          fs14.writeSync(traceFd, `
 ]
 `);
-          fs12.closeSync(traceFd);
+          fs14.closeSync(traceFd);
           tracing = void 0;
           if (typeCatalog.length) {
             dumpTypes(typeCatalog);
@@ -8872,11 +8872,11 @@ ${lanes.join("\n")}
         function writeEvent(eventType, phase, name, args, extras, time = 1e3 * timestamp()) {
           if (mode === "server" && phase === "checkTypes") return;
           mark("beginTracing");
-          fs12.writeSync(traceFd, `,
+          fs14.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
-          if (extras) fs12.writeSync(traceFd, `,${extras}`);
-          if (args) fs12.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-          fs12.writeSync(traceFd, `}`);
+          if (extras) fs14.writeSync(traceFd, `,${extras}`);
+          if (args) fs14.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+          fs14.writeSync(traceFd, `}`);
           mark("endTracing");
           measure("Tracing", "beginTracing", "endTracing");
         }
@@ -8898,9 +8898,9 @@ ${lanes.join("\n")}
           var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
           mark("beginDumpTypes");
           const typesPath = legend[legend.length - 1].typesPath;
-          const typesFd = fs12.openSync(typesPath, "w");
+          const typesFd = fs14.openSync(typesPath, "w");
           const recursionIdentityMap = /* @__PURE__ */ new Map();
-          fs12.writeSync(typesFd, "[");
+          fs14.writeSync(typesFd, "[");
           const numTypes = types.length;
           for (let i = 0; i < numTypes; i++) {
             const type = types[i];
@@ -8996,13 +8996,13 @@ ${lanes.join("\n")}
               flags: Debug.formatTypeFlags(type.flags).split("|"),
               display
             };
-            fs12.writeSync(typesFd, JSON.stringify(descriptor));
+            fs14.writeSync(typesFd, JSON.stringify(descriptor));
             if (i < numTypes - 1) {
-              fs12.writeSync(typesFd, ",\n");
+              fs14.writeSync(typesFd, ",\n");
             }
           }
-          fs12.writeSync(typesFd, "]\n");
-          fs12.closeSync(typesFd);
+          fs14.writeSync(typesFd, "]\n");
+          fs14.closeSync(typesFd);
           mark("endDumpTypes");
           measure("Dump types", "beginDumpTypes", "endDumpTypes");
         }
@@ -9010,7 +9010,7 @@ ${lanes.join("\n")}
           if (!legendPath) {
             return;
           }
-          fs12.writeFileSync(legendPath, JSON.stringify(legend));
+          fs14.writeFileSync(legendPath, JSON.stringify(legend));
         }
         tracingEnabled2.dumpLegend = dumpLegend;
       })(tracingEnabled || (tracingEnabled = {}));
@@ -11392,17 +11392,17 @@ ${lanes.join("\n")}
       }
       function createSingleWatcherPerName(cache, useCaseSensitiveFileNames2, name, callback, createWatcher) {
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
-        const path10 = toCanonicalFileName(name);
-        const existing = cache.get(path10);
+        const path11 = toCanonicalFileName(name);
+        const existing = cache.get(path11);
         if (existing) {
           existing.callbacks.push(callback);
         } else {
-          cache.set(path10, {
+          cache.set(path11, {
             watcher: createWatcher(
               // Cant infer types correctly so lets satisfy checker
               (param1, param2, param3) => {
                 var _a;
-                return (_a = cache.get(path10)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
+                return (_a = cache.get(path11)) == null ? void 0 : _a.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
               }
             ),
             callbacks: [callback]
@@ -11410,10 +11410,10 @@ ${lanes.join("\n")}
         }
         return {
           close: () => {
-            const watcher = cache.get(path10);
+            const watcher = cache.get(path11);
             if (!watcher) return;
             if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) return;
-            cache.delete(path10);
+            cache.delete(path11);
             closeFileWatcherOf(watcher);
           }
         };
@@ -11665,13 +11665,13 @@ ${lanes.join("\n")}
             (newChildWatches || (newChildWatches = [])).push(childWatcher);
           }
         }
-        function isIgnoredPath(path10, options) {
-          return some(ignoredPaths, (searchPath) => isInPath(path10, searchPath)) || isIgnoredByWatchOptions(path10, options, useCaseSensitiveFileNames2, getCurrentDirectory);
+        function isIgnoredPath(path11, options) {
+          return some(ignoredPaths, (searchPath) => isInPath(path11, searchPath)) || isIgnoredByWatchOptions(path11, options, useCaseSensitiveFileNames2, getCurrentDirectory);
         }
-        function isInPath(path10, searchPath) {
-          if (path10.includes(searchPath)) return true;
+        function isInPath(path11, searchPath) {
+          if (path11.includes(searchPath)) return true;
           if (useCaseSensitiveFileNames2) return false;
-          return toCanonicalFilePath(path10).includes(searchPath);
+          return toCanonicalFilePath(path11).includes(searchPath);
         }
       }
       var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
@@ -12049,8 +12049,8 @@ ${lanes.join("\n")}
       }
       function patchWriteFileEnsuringDirectory(sys2) {
         const originalWriteFile = sys2.writeFile;
-        sys2.writeFile = (path10, data, writeBom) => writeFileEnsuringDirectories(
-          path10,
+        sys2.writeFile = (path11, data, writeBom) => writeFileEnsuringDirectories(
+          path11,
           data,
           !!writeBom,
           (path22, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path22, data2, writeByteOrderMark),
@@ -12094,7 +12094,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: (path10) => getAccessibleFileSystemEntries(path10).directories,
+            getAccessibleSortedChildDirectories: (path11) => getAccessibleFileSystemEntries(path11).directories,
             realpath,
             tscWatchFile: process.env.TSC_WATCHFILE,
             useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
@@ -12121,7 +12121,7 @@ ${lanes.join("\n")}
             watchFile: watchFile2,
             watchDirectory,
             preferNonRecursiveWatch: !fsSupportsRecursiveFsWatch,
-            resolvePath: (path10) => _path.resolve(path10),
+            resolvePath: (path11) => _path.resolve(path11),
             fileExists,
             directoryExists,
             getAccessibleFileSystemEntries,
@@ -12156,8 +12156,8 @@ ${lanes.join("\n")}
               }
               return process.memoryUsage().heapUsed;
             },
-            getFileSize(path10) {
-              const stat = statSync2(path10);
+            getFileSize(path11) {
+              const stat = statSync2(path11);
               if (stat == null ? void 0 : stat.isFile()) {
                 return stat.size;
               }
@@ -12201,14 +12201,14 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync2(path10) {
+          function statSync2(path11) {
             try {
-              return _fs.statSync(path10, statSyncOptions);
+              return _fs.statSync(path11, statSyncOptions);
             } catch {
               return void 0;
             }
           }
-          function enableCPUProfiler(path10, cb) {
+          function enableCPUProfiler(path11, cb) {
             if (activeSession) {
               cb();
               return false;
@@ -12223,7 +12223,7 @@ ${lanes.join("\n")}
             session.post("Profiler.enable", () => {
               session.post("Profiler.start", () => {
                 activeSession = session;
-                profilePath = path10;
+                profilePath = path11;
                 cb();
               });
             });
@@ -12367,9 +12367,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          function getAccessibleFileSystemEntries(path10) {
+          function getAccessibleFileSystemEntries(path11) {
             try {
-              const entries = _fs.readdirSync(path10 || ".", { withFileTypes: true });
+              const entries = _fs.readdirSync(path11 || ".", { withFileTypes: true });
               const files = [];
               const directories = [];
               for (const dirent of entries) {
@@ -12379,7 +12379,7 @@ ${lanes.join("\n")}
                 }
                 let stat;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
-                  const name = combinePaths(path10, entry);
+                  const name = combinePaths(path11, entry);
                   stat = statSync2(name);
                   if (!stat) {
                     continue;
@@ -12400,11 +12400,11 @@ ${lanes.join("\n")}
               return emptyFileSystemEntries;
             }
           }
-          function readDirectory(path10, extensions, excludes, includes, depth) {
-            return matchFiles(path10, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
+          function readDirectory(path11, extensions, excludes, includes, depth) {
+            return matchFiles(path11, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
-          function fileSystemEntryExists(path10, entryKind) {
-            const stat = statSync2(path10);
+          function fileSystemEntryExists(path11, entryKind) {
+            const stat = statSync2(path11);
             if (!stat) {
               return false;
             }
@@ -12417,47 +12417,47 @@ ${lanes.join("\n")}
                 return false;
             }
           }
-          function fileExists(path10) {
+          function fileExists(path11) {
             return fileSystemEntryExists(
-              path10,
+              path11,
               0
               /* File */
             );
           }
-          function directoryExists(path10) {
+          function directoryExists(path11) {
             return fileSystemEntryExists(
-              path10,
+              path11,
               1
               /* Directory */
             );
           }
-          function getDirectories(path10) {
-            return getAccessibleFileSystemEntries(path10).directories.slice();
+          function getDirectories(path11) {
+            return getAccessibleFileSystemEntries(path11).directories.slice();
           }
-          function fsRealPathHandlingLongPath(path10) {
-            return path10.length < 260 ? _fs.realpathSync.native(path10) : _fs.realpathSync(path10);
+          function fsRealPathHandlingLongPath(path11) {
+            return path11.length < 260 ? _fs.realpathSync.native(path11) : _fs.realpathSync(path11);
           }
-          function realpath(path10) {
+          function realpath(path11) {
             try {
-              return fsRealpath(path10);
+              return fsRealpath(path11);
             } catch {
-              return path10;
+              return path11;
             }
           }
-          function getModifiedTime3(path10) {
+          function getModifiedTime3(path11) {
             var _a;
-            return (_a = statSync2(path10)) == null ? void 0 : _a.mtime;
+            return (_a = statSync2(path11)) == null ? void 0 : _a.mtime;
           }
-          function setModifiedTime(path10, time) {
+          function setModifiedTime(path11, time) {
             try {
-              _fs.utimesSync(path10, time, time);
+              _fs.utimesSync(path11, time, time);
             } catch {
               return;
             }
           }
-          function deleteFile(path10) {
+          function deleteFile(path11) {
             try {
-              return _fs.unlinkSync(path10);
+              return _fs.unlinkSync(path11);
             } catch {
               return;
             }
@@ -12497,41 +12497,41 @@ ${lanes.join("\n")}
       function isAnyDirectorySeparator(charCode) {
         return charCode === 47 || charCode === 92;
       }
-      function isUrl(path10) {
-        return getEncodedRootLength(path10) < 0;
+      function isUrl(path11) {
+        return getEncodedRootLength(path11) < 0;
       }
-      function isRootedDiskPath(path10) {
-        return getEncodedRootLength(path10) > 0;
+      function isRootedDiskPath(path11) {
+        return getEncodedRootLength(path11) > 0;
       }
-      function isDiskPathRoot(path10) {
-        const rootLength = getEncodedRootLength(path10);
-        return rootLength > 0 && rootLength === path10.length;
+      function isDiskPathRoot(path11) {
+        const rootLength = getEncodedRootLength(path11);
+        return rootLength > 0 && rootLength === path11.length;
       }
-      function pathIsAbsolute(path10) {
-        return getEncodedRootLength(path10) !== 0;
+      function pathIsAbsolute(path11) {
+        return getEncodedRootLength(path11) !== 0;
       }
-      function pathIsRelative(path10) {
-        return /^\.\.?(?:$|[\\/])/.test(path10);
+      function pathIsRelative(path11) {
+        return /^\.\.?(?:$|[\\/])/.test(path11);
       }
-      function pathIsBareSpecifier(path10) {
-        return !pathIsAbsolute(path10) && !pathIsRelative(path10);
+      function pathIsBareSpecifier(path11) {
+        return !pathIsAbsolute(path11) && !pathIsRelative(path11);
       }
       function hasExtension(fileName) {
         return getBaseFileName(fileName).includes(".");
       }
-      function fileExtensionIs(path10, extension) {
-        return path10.length > extension.length && endsWith(path10, extension);
+      function fileExtensionIs(path11, extension) {
+        return path11.length > extension.length && endsWith(path11, extension);
       }
-      function fileExtensionIsOneOf(path10, extensions) {
+      function fileExtensionIsOneOf(path11, extensions) {
         for (const extension of extensions) {
-          if (fileExtensionIs(path10, extension)) {
+          if (fileExtensionIs(path11, extension)) {
             return true;
           }
         }
         return false;
       }
-      function hasTrailingDirectorySeparator(path10) {
-        return path10.length > 0 && isAnyDirectorySeparator(path10.charCodeAt(path10.length - 1));
+      function hasTrailingDirectorySeparator(path11) {
+        return path11.length > 0 && isAnyDirectorySeparator(path11.charCodeAt(path11.length - 1));
       }
       function isVolumeCharacter(charCode) {
         return charCode >= 97 && charCode <= 122 || charCode >= 65 && charCode <= 90;
@@ -12545,111 +12545,111 @@ ${lanes.join("\n")}
         }
         return -1;
       }
-      function getEncodedRootLength(path10) {
-        if (!path10) return 0;
-        const ch0 = path10.charCodeAt(0);
+      function getEncodedRootLength(path11) {
+        if (!path11) return 0;
+        const ch0 = path11.charCodeAt(0);
         if (ch0 === 47 || ch0 === 92) {
-          if (path10.charCodeAt(1) !== ch0) return 1;
-          const p1 = path10.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
-          if (p1 < 0) return path10.length;
+          if (path11.charCodeAt(1) !== ch0) return 1;
+          const p1 = path11.indexOf(ch0 === 47 ? directorySeparator : altDirectorySeparator, 2);
+          if (p1 < 0) return path11.length;
           return p1 + 1;
         }
-        if (isVolumeCharacter(ch0) && path10.charCodeAt(1) === 58) {
-          const ch2 = path10.charCodeAt(2);
+        if (isVolumeCharacter(ch0) && path11.charCodeAt(1) === 58) {
+          const ch2 = path11.charCodeAt(2);
           if (ch2 === 47 || ch2 === 92) return 3;
-          if (path10.length === 2) return 2;
+          if (path11.length === 2) return 2;
         }
-        const schemeEnd = path10.indexOf(urlSchemeSeparator);
+        const schemeEnd = path11.indexOf(urlSchemeSeparator);
         if (schemeEnd !== -1) {
           const authorityStart = schemeEnd + urlSchemeSeparator.length;
-          const authorityEnd = path10.indexOf(directorySeparator, authorityStart);
+          const authorityEnd = path11.indexOf(directorySeparator, authorityStart);
           if (authorityEnd !== -1) {
-            const scheme = path10.slice(0, schemeEnd);
-            const authority = path10.slice(authorityStart, authorityEnd);
-            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path10.charCodeAt(authorityEnd + 1))) {
-              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path10, authorityEnd + 2);
+            const scheme = path11.slice(0, schemeEnd);
+            const authority = path11.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path11.charCodeAt(authorityEnd + 1))) {
+              const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path11, authorityEnd + 2);
               if (volumeSeparatorEnd !== -1) {
-                if (path10.charCodeAt(volumeSeparatorEnd) === 47) {
+                if (path11.charCodeAt(volumeSeparatorEnd) === 47) {
                   return ~(volumeSeparatorEnd + 1);
                 }
-                if (volumeSeparatorEnd === path10.length) {
+                if (volumeSeparatorEnd === path11.length) {
                   return ~volumeSeparatorEnd;
                 }
               }
             }
             return ~(authorityEnd + 1);
           }
-          return ~path10.length;
+          return ~path11.length;
         }
         return 0;
       }
-      function getRootLength(path10) {
-        const rootLength = getEncodedRootLength(path10);
+      function getRootLength(path11) {
+        const rootLength = getEncodedRootLength(path11);
         return rootLength < 0 ? ~rootLength : rootLength;
       }
-      function getDirectoryPath(path10) {
-        path10 = normalizeSlashes(path10);
-        const rootLength = getRootLength(path10);
-        if (rootLength === path10.length) return path10;
-        path10 = removeTrailingDirectorySeparator(path10);
-        return path10.slice(0, Math.max(rootLength, path10.lastIndexOf(directorySeparator)));
-      }
-      function getBaseFileName(path10, extensions, ignoreCase) {
-        path10 = normalizeSlashes(path10);
-        const rootLength = getRootLength(path10);
-        if (rootLength === path10.length) return "";
-        path10 = removeTrailingDirectorySeparator(path10);
-        const name = path10.slice(Math.max(getRootLength(path10), path10.lastIndexOf(directorySeparator) + 1));
+      function getDirectoryPath(path11) {
+        path11 = normalizeSlashes(path11);
+        const rootLength = getRootLength(path11);
+        if (rootLength === path11.length) return path11;
+        path11 = removeTrailingDirectorySeparator(path11);
+        return path11.slice(0, Math.max(rootLength, path11.lastIndexOf(directorySeparator)));
+      }
+      function getBaseFileName(path11, extensions, ignoreCase) {
+        path11 = normalizeSlashes(path11);
+        const rootLength = getRootLength(path11);
+        if (rootLength === path11.length) return "";
+        path11 = removeTrailingDirectorySeparator(path11);
+        const name = path11.slice(Math.max(getRootLength(path11), path11.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(path10, extension, stringEqualityComparer) {
+      function tryGetExtensionFromPath(path11, extension, stringEqualityComparer) {
         if (!startsWith(extension, ".")) extension = "." + extension;
-        if (path10.length >= extension.length && path10.charCodeAt(path10.length - extension.length) === 46) {
-          const pathExtension = path10.slice(path10.length - extension.length);
+        if (path11.length >= extension.length && path11.charCodeAt(path11.length - extension.length) === 46) {
+          const pathExtension = path11.slice(path11.length - extension.length);
           if (stringEqualityComparer(pathExtension, extension)) {
             return pathExtension;
           }
         }
       }
-      function getAnyExtensionFromPathWorker(path10, extensions, stringEqualityComparer) {
+      function getAnyExtensionFromPathWorker(path11, extensions, stringEqualityComparer) {
         if (typeof extensions === "string") {
-          return tryGetExtensionFromPath(path10, extensions, stringEqualityComparer) || "";
+          return tryGetExtensionFromPath(path11, extensions, stringEqualityComparer) || "";
         }
         for (const extension of extensions) {
-          const result = tryGetExtensionFromPath(path10, extension, stringEqualityComparer);
+          const result = tryGetExtensionFromPath(path11, extension, stringEqualityComparer);
           if (result) return result;
         }
         return "";
       }
-      function getAnyExtensionFromPath(path10, extensions, ignoreCase) {
+      function getAnyExtensionFromPath(path11, extensions, ignoreCase) {
         if (extensions) {
-          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path10), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
+          return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path11), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
         }
-        const baseFileName = getBaseFileName(path10);
+        const baseFileName = getBaseFileName(path11);
         const extensionIndex = baseFileName.lastIndexOf(".");
         if (extensionIndex >= 0) {
           return baseFileName.substring(extensionIndex);
         }
         return "";
       }
-      function pathComponents(path10, rootLength) {
-        const root = path10.substring(0, rootLength);
-        const rest = path10.substring(rootLength).split(directorySeparator);
+      function pathComponents(path11, rootLength) {
+        const root = path11.substring(0, rootLength);
+        const rest = path11.substring(rootLength).split(directorySeparator);
         if (rest.length && !lastOrUndefined(rest)) rest.pop();
         return [root, ...rest];
       }
-      function getPathComponents(path10, currentDirectory = "") {
-        path10 = combinePaths(currentDirectory, path10);
-        return pathComponents(path10, getRootLength(path10));
+      function getPathComponents(path11, currentDirectory = "") {
+        path11 = combinePaths(currentDirectory, path11);
+        return pathComponents(path11, getRootLength(path11));
       }
       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(path10) {
-        return path10.includes("\\") ? path10.replace(backslashRegExp, directorySeparator) : path10;
+      function normalizeSlashes(path11) {
+        return path11.includes("\\") ? path11.replace(backslashRegExp, directorySeparator) : path11;
       }
       function reducePathComponents(components) {
         if (!some(components)) return [];
@@ -12670,39 +12670,39 @@ ${lanes.join("\n")}
         }
         return reduced;
       }
-      function combinePaths(path10, ...paths) {
-        if (path10) path10 = normalizeSlashes(path10);
+      function combinePaths(path11, ...paths) {
+        if (path11) path11 = normalizeSlashes(path11);
         for (let relativePath of paths) {
           if (!relativePath) continue;
           relativePath = normalizeSlashes(relativePath);
-          if (!path10 || getRootLength(relativePath) !== 0) {
-            path10 = relativePath;
+          if (!path11 || getRootLength(relativePath) !== 0) {
+            path11 = relativePath;
           } else {
-            path10 = ensureTrailingDirectorySeparator(path10) + relativePath;
+            path11 = ensureTrailingDirectorySeparator(path11) + relativePath;
           }
         }
-        return path10;
+        return path11;
       }
-      function resolvePath(path10, ...paths) {
-        return normalizePath(some(paths) ? combinePaths(path10, ...paths) : normalizeSlashes(path10));
+      function resolvePath(path11, ...paths) {
+        return normalizePath(some(paths) ? combinePaths(path11, ...paths) : normalizeSlashes(path11));
       }
-      function getNormalizedPathComponents(path10, currentDirectory) {
-        return reducePathComponents(getPathComponents(path10, currentDirectory));
+      function getNormalizedPathComponents(path11, currentDirectory) {
+        return reducePathComponents(getPathComponents(path11, currentDirectory));
       }
-      function getNormalizedAbsolutePath(path10, currentDirectory) {
-        let rootLength = getRootLength(path10);
+      function getNormalizedAbsolutePath(path11, currentDirectory) {
+        let rootLength = getRootLength(path11);
         if (rootLength === 0 && currentDirectory) {
-          path10 = combinePaths(currentDirectory, path10);
-          rootLength = getRootLength(path10);
+          path11 = combinePaths(currentDirectory, path11);
+          rootLength = getRootLength(path11);
         } else {
-          path10 = normalizeSlashes(path10);
+          path11 = normalizeSlashes(path11);
         }
-        const simpleNormalized = simpleNormalizePath(path10);
+        const simpleNormalized = simpleNormalizePath(path11);
         if (simpleNormalized !== void 0) {
           return simpleNormalized.length > rootLength ? removeTrailingDirectorySeparator(simpleNormalized) : simpleNormalized;
         }
-        const length2 = path10.length;
-        const root = path10.substring(0, rootLength);
+        const length2 = path11.length;
+        const root = path11.substring(0, rootLength);
         let normalized;
         let index = rootLength;
         let segmentStart = index;
@@ -12710,23 +12710,23 @@ ${lanes.join("\n")}
         let seenNonDotDotSegment = rootLength !== 0;
         while (index < length2) {
           segmentStart = index;
-          let ch = path10.charCodeAt(index);
+          let ch = path11.charCodeAt(index);
           while (ch === 47 && index + 1 < length2) {
             index++;
-            ch = path10.charCodeAt(index);
+            ch = path11.charCodeAt(index);
           }
           if (index > segmentStart) {
-            normalized ?? (normalized = path10.substring(0, segmentStart - 1));
+            normalized ?? (normalized = path11.substring(0, segmentStart - 1));
             segmentStart = index;
           }
-          let segmentEnd = path10.indexOf(directorySeparator, index + 1);
+          let segmentEnd = path11.indexOf(directorySeparator, index + 1);
           if (segmentEnd === -1) {
             segmentEnd = length2;
           }
           const segmentLength = segmentEnd - segmentStart;
-          if (segmentLength === 1 && path10.charCodeAt(index) === 46) {
-            normalized ?? (normalized = path10.substring(0, normalizedUpTo));
-          } else if (segmentLength === 2 && path10.charCodeAt(index) === 46 && path10.charCodeAt(index + 1) === 46) {
+          if (segmentLength === 1 && path11.charCodeAt(index) === 46) {
+            normalized ?? (normalized = path11.substring(0, normalizedUpTo));
+          } else if (segmentLength === 2 && path11.charCodeAt(index) === 46 && path11.charCodeAt(index + 1) === 46) {
             if (!seenNonDotDotSegment) {
               if (normalized !== void 0) {
                 normalized += normalized.length === rootLength ? ".." : "/..";
@@ -12735,9 +12735,9 @@ ${lanes.join("\n")}
               }
             } else if (normalized === void 0) {
               if (normalizedUpTo - 2 >= 0) {
-                normalized = path10.substring(0, Math.max(rootLength, path10.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
+                normalized = path11.substring(0, Math.max(rootLength, path11.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
               } else {
-                normalized = path10.substring(0, normalizedUpTo);
+                normalized = path11.substring(0, normalizedUpTo);
               }
             } else {
               const lastSlash = normalized.lastIndexOf(directorySeparator);
@@ -12755,36 +12755,36 @@ ${lanes.join("\n")}
               normalized += directorySeparator;
             }
             seenNonDotDotSegment = true;
-            normalized += path10.substring(segmentStart, segmentEnd);
+            normalized += path11.substring(segmentStart, segmentEnd);
           } else {
             seenNonDotDotSegment = true;
             normalizedUpTo = segmentEnd;
           }
           index = segmentEnd + 1;
         }
-        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path10) : path10);
+        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path11) : path11);
       }
-      function normalizePath(path10) {
-        path10 = normalizeSlashes(path10);
-        let normalized = simpleNormalizePath(path10);
+      function normalizePath(path11) {
+        path11 = normalizeSlashes(path11);
+        let normalized = simpleNormalizePath(path11);
         if (normalized !== void 0) {
           return normalized;
         }
-        normalized = getNormalizedAbsolutePath(path10, "");
-        return normalized && hasTrailingDirectorySeparator(path10) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+        normalized = getNormalizedAbsolutePath(path11, "");
+        return normalized && hasTrailingDirectorySeparator(path11) ? ensureTrailingDirectorySeparator(normalized) : normalized;
       }
-      function simpleNormalizePath(path10) {
-        if (!relativePathSegmentRegExp.test(path10)) {
-          return path10;
+      function simpleNormalizePath(path11) {
+        if (!relativePathSegmentRegExp.test(path11)) {
+          return path11;
         }
-        let simplified = path10.replace(/\/\.\//g, "/");
+        let simplified = path11.replace(/\/\.\//g, "/");
         if (simplified.startsWith("./")) {
           simplified = simplified.slice(2);
         }
-        if (simplified !== path10) {
-          path10 = simplified;
-          if (!relativePathSegmentRegExp.test(path10)) {
-            return path10;
+        if (simplified !== path11) {
+          path11 = simplified;
+          if (!relativePathSegmentRegExp.test(path11)) {
+            return path11;
           }
         }
         return void 0;
@@ -12800,31 +12800,31 @@ ${lanes.join("\n")}
         const nonCanonicalizedPath = isRootedDiskPath(fileName) ? normalizePath(fileName) : getNormalizedAbsolutePath(fileName, basePath);
         return getCanonicalFileName(nonCanonicalizedPath);
       }
-      function removeTrailingDirectorySeparator(path10) {
-        if (hasTrailingDirectorySeparator(path10)) {
-          return path10.substr(0, path10.length - 1);
+      function removeTrailingDirectorySeparator(path11) {
+        if (hasTrailingDirectorySeparator(path11)) {
+          return path11.substr(0, path11.length - 1);
         }
-        return path10;
+        return path11;
       }
-      function ensureTrailingDirectorySeparator(path10) {
-        if (!hasTrailingDirectorySeparator(path10)) {
-          return path10 + directorySeparator;
+      function ensureTrailingDirectorySeparator(path11) {
+        if (!hasTrailingDirectorySeparator(path11)) {
+          return path11 + directorySeparator;
         }
-        return path10;
+        return path11;
       }
-      function ensurePathIsNonModuleName(path10) {
-        return !pathIsAbsolute(path10) && !pathIsRelative(path10) ? "./" + path10 : path10;
+      function ensurePathIsNonModuleName(path11) {
+        return !pathIsAbsolute(path11) && !pathIsRelative(path11) ? "./" + path11 : path11;
       }
-      function changeAnyExtension(path10, ext, extensions, ignoreCase) {
-        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path10, extensions, ignoreCase) : getAnyExtensionFromPath(path10);
-        return pathext ? path10.slice(0, path10.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path10;
+      function changeAnyExtension(path11, ext, extensions, ignoreCase) {
+        const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path11, extensions, ignoreCase) : getAnyExtensionFromPath(path11);
+        return pathext ? path11.slice(0, path11.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path11;
       }
-      function changeFullExtension(path10, newExtension) {
-        const declarationExtension = getDeclarationFileExtension(path10);
+      function changeFullExtension(path11, newExtension) {
+        const declarationExtension = getDeclarationFileExtension(path11);
         if (declarationExtension) {
-          return path10.slice(0, path10.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
+          return path11.slice(0, path11.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
         }
-        return changeAnyExtension(path10, newExtension);
+        return changeAnyExtension(path11, newExtension);
       }
       var relativePathSegmentRegExp = /\/\/|(?:^|\/)\.\.?(?:$|\/)/;
       function comparePathsWorker(a, b, componentComparer) {
@@ -24277,8 +24277,8 @@ ${lanes.join("\n")}
       function getResolvedExternalModuleName(host, file, referenceFile) {
         return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName);
       }
-      function getCanonicalAbsolutePath(host, path10) {
-        return host.getCanonicalFileName(getNormalizedAbsolutePath(path10, host.getCurrentDirectory()));
+      function getCanonicalAbsolutePath(host, path11) {
+        return host.getCanonicalFileName(getNormalizedAbsolutePath(path11, host.getCurrentDirectory()));
       }
       function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
         const file = resolver.getExternalModuleFileFromDeclaration(declaration);
@@ -24321,20 +24321,20 @@ ${lanes.join("\n")}
       }
       function getDeclarationEmitOutputFilePathWorker(fileName, options, host) {
         const outputDir = options.declarationDir || options.outDir;
-        const path10 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
-        const declarationExtension = getDeclarationEmitExtensionForPath(path10);
-        return removeFileExtension(path10) + declarationExtension;
+        const path11 = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f)) : fileName;
+        const declarationExtension = getDeclarationEmitExtensionForPath(path11);
+        return removeFileExtension(path11) + declarationExtension;
       }
-      function getDeclarationEmitExtensionForPath(path10) {
-        return fileExtensionIsOneOf(path10, [
+      function getDeclarationEmitExtensionForPath(path11) {
+        return fileExtensionIsOneOf(path11, [
           ".mjs",
           ".mts"
           /* Mts */
-        ]) ? ".d.mts" : fileExtensionIsOneOf(path10, [
+        ]) ? ".d.mts" : fileExtensionIsOneOf(path11, [
           ".cjs",
           ".cts"
           /* Cts */
-        ]) ? ".d.cts" : fileExtensionIsOneOf(path10, [
+        ]) ? ".d.cts" : fileExtensionIsOneOf(path11, [
           ".json"
           /* Json */
         ]) ? `.d.json.ts` : (
@@ -24342,8 +24342,8 @@ ${lanes.join("\n")}
           ".d.ts"
         );
       }
-      function getPossibleOriginalInputExtensionForExtension(path10) {
-        return fileExtensionIsOneOf(path10, [
+      function getPossibleOriginalInputExtensionForExtension(path11) {
+        return fileExtensionIsOneOf(path11, [
           ".d.mts",
           ".mjs",
           ".mts"
@@ -24352,7 +24352,7 @@ ${lanes.join("\n")}
           ".mts",
           ".mjs"
           /* Mjs */
-        ] : fileExtensionIsOneOf(path10, [
+        ] : fileExtensionIsOneOf(path11, [
           ".d.cts",
           ".cjs",
           ".cts"
@@ -24361,7 +24361,7 @@ ${lanes.join("\n")}
           ".cts",
           ".cjs"
           /* Cjs */
-        ] : fileExtensionIsOneOf(path10, [`.d.json.ts`]) ? [
+        ] : fileExtensionIsOneOf(path11, [`.d.json.ts`]) ? [
           ".json"
           /* Json */
         ] : [
@@ -24446,12 +24446,12 @@ ${lanes.join("\n")}
           createDirectory(directoryPath);
         }
       }
-      function writeFileEnsuringDirectories(path10, data, writeByteOrderMark, writeFile22, createDirectory, directoryExists) {
+      function writeFileEnsuringDirectories(path11, data, writeByteOrderMark, writeFile22, createDirectory, directoryExists) {
         try {
-          writeFile22(path10, data, writeByteOrderMark);
+          writeFile22(path11, data, writeByteOrderMark);
         } catch {
-          ensureDirectoriesExist(getDirectoryPath(normalizePath(path10)), createDirectory, directoryExists);
-          writeFile22(path10, data, writeByteOrderMark);
+          ensureDirectoriesExist(getDirectoryPath(normalizePath(path11)), createDirectory, directoryExists);
+          writeFile22(path11, data, writeByteOrderMark);
         }
       }
       function getLineOfLocalPosition(sourceFile, pos) {
@@ -25151,20 +25151,20 @@ ${lanes.join("\n")}
         }
         return getStringFromExpandedCharCodes(expandedCharCodes);
       }
-      function readJsonOrUndefined(path10, hostOrText) {
-        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path10);
+      function readJsonOrUndefined(path11, hostOrText) {
+        const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path11);
         if (!jsonText) return void 0;
         let result = tryParseJson(jsonText);
         if (result === void 0) {
-          const looseResult = parseConfigFileTextToJson(path10, jsonText);
+          const looseResult = parseConfigFileTextToJson(path11, jsonText);
           if (!looseResult.error) {
             result = looseResult.config;
           }
         }
         return result;
       }
-      function readJson2(path10, host) {
-        return readJsonOrUndefined(path10, host) || {};
+      function readJson2(path11, host) {
+        return readJsonOrUndefined(path11, host) || {};
       }
       function tryParseJson(text) {
         try {
@@ -26314,7 +26314,7 @@ ${lanes.join("\n")}
           getSymlinkedFiles: () => symlinkedFiles,
           getSymlinkedDirectories: () => symlinkedDirectories,
           getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
-          setSymlinkedFile: (path10, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path10, real),
+          setSymlinkedFile: (path11, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path11, real),
           setSymlinkedDirectory: (symlink, real) => {
             let symlinkPath = toPath(symlink, cwd, getCanonicalFileName);
             if (!containsIgnoredPath(symlinkPath)) {
@@ -26374,8 +26374,8 @@ ${lanes.join("\n")}
       function stripLeadingDirectorySeparator(s) {
         return isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : void 0;
       }
-      function tryRemoveDirectoryPrefix(path10, dirPath, getCanonicalFileName) {
-        const withoutPrefix = tryRemovePrefix(path10, dirPath, getCanonicalFileName);
+      function tryRemoveDirectoryPrefix(path11, dirPath, getCanonicalFileName) {
+        const withoutPrefix = tryRemovePrefix(path11, dirPath, getCanonicalFileName);
         return withoutPrefix === void 0 ? void 0 : stripLeadingDirectorySeparator(withoutPrefix);
       }
       var reservedCharacterPattern = /[^\w\s/]/g;
@@ -26501,25 +26501,25 @@ ${lanes.join("\n")}
       function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
         return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
       }
-      function getFileMatcherPatterns(path10, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
-        path10 = normalizePath(path10);
+      function getFileMatcherPatterns(path11, excludes, includes, useCaseSensitiveFileNames2, currentDirectory) {
+        path11 = normalizePath(path11);
         currentDirectory = normalizePath(currentDirectory);
-        const absolutePath = combinePaths(currentDirectory, path10);
+        const absolutePath = combinePaths(currentDirectory, path11);
         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(path10, includes, useCaseSensitiveFileNames2)
+          basePaths: getBasePaths(path11, includes, useCaseSensitiveFileNames2)
         };
       }
       function getRegexFromPattern(pattern, useCaseSensitiveFileNames2) {
         return new RegExp(pattern, useCaseSensitiveFileNames2 ? "" : "i");
       }
-      function matchFiles(path10, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
-        path10 = normalizePath(path10);
+      function matchFiles(path11, extensions, excludes, includes, useCaseSensitiveFileNames2, currentDirectory, depth, getFileSystemEntries, realpath) {
+        path11 = normalizePath(path11);
         currentDirectory = normalizePath(currentDirectory);
-        const patterns = getFileMatcherPatterns(path10, excludes, includes, useCaseSensitiveFileNames2, currentDirectory);
+        const patterns = getFileMatcherPatterns(path11, 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);
@@ -26564,17 +26564,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function getBasePaths(path10, includes, useCaseSensitiveFileNames2) {
-        const basePaths = [path10];
+      function getBasePaths(path11, includes, useCaseSensitiveFileNames2) {
+        const basePaths = [path11];
         if (includes) {
           const includeBasePaths = [];
           for (const include of includes) {
-            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path10, include));
+            const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path11, include));
             includeBasePaths.push(getIncludeBasePath(absolute));
           }
           includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames2));
           for (const includeBasePath of includeBasePaths) {
-            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path10, !useCaseSensitiveFileNames2))) {
+            if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path11, !useCaseSensitiveFileNames2))) {
               basePaths.push(includeBasePath);
             }
           }
@@ -26838,24 +26838,24 @@ ${lanes.join("\n")}
         ".json"
         /* Json */
       ];
-      function removeFileExtension(path10) {
+      function removeFileExtension(path11) {
         for (const ext of extensionsToRemove) {
-          const extensionless = tryRemoveExtension(path10, ext);
+          const extensionless = tryRemoveExtension(path11, ext);
           if (extensionless !== void 0) {
             return extensionless;
           }
         }
-        return path10;
+        return path11;
       }
-      function tryRemoveExtension(path10, extension) {
-        return fileExtensionIs(path10, extension) ? removeExtension(path10, extension) : void 0;
+      function tryRemoveExtension(path11, extension) {
+        return fileExtensionIs(path11, extension) ? removeExtension(path11, extension) : void 0;
       }
-      function removeExtension(path10, extension) {
-        return path10.substring(0, path10.length - extension.length);
+      function removeExtension(path11, extension) {
+        return path11.substring(0, path11.length - extension.length);
       }
-      function changeExtension(path10, newExtension) {
+      function changeExtension(path11, newExtension) {
         return changeAnyExtension(
-          path10,
+          path11,
           newExtension,
           extensionsToRemove,
           /*ignoreCase*/
@@ -26881,8 +26881,8 @@ ${lanes.join("\n")}
         let matchableStringSet;
         let patterns;
         const pathList = getOwnKeys(paths);
-        for (const path10 of pathList) {
-          const patternOrStr = tryParsePattern(path10);
+        for (const path11 of pathList) {
+          const patternOrStr = tryParsePattern(path11);
           if (patternOrStr === void 0) {
             continue;
           } else if (typeof patternOrStr === "string") {
@@ -26909,15 +26909,15 @@ ${lanes.join("\n")}
       function resolutionExtensionIsTSOrJson(ext) {
         return extensionIsTS(ext) || ext === ".json";
       }
-      function extensionFromPath(path10) {
-        const ext = tryGetExtensionFromPath2(path10);
-        return ext !== void 0 ? ext : Debug.fail(`File ${path10} has unknown extension.`);
+      function extensionFromPath(path11) {
+        const ext = tryGetExtensionFromPath2(path11);
+        return ext !== void 0 ? ext : Debug.fail(`File ${path11} has unknown extension.`);
       }
-      function isAnySupportedFileExtension(path10) {
-        return tryGetExtensionFromPath2(path10) !== void 0;
+      function isAnySupportedFileExtension(path11) {
+        return tryGetExtensionFromPath2(path11) !== void 0;
       }
-      function tryGetExtensionFromPath2(path10) {
-        return find(extensionsToRemove, (e) => fileExtensionIs(path10, e));
+      function tryGetExtensionFromPath2(path11) {
+        return find(extensionsToRemove, (e) => fileExtensionIs(path11, e));
       }
       function isCheckJsEnabledForFile(sourceFile, compilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
@@ -27226,8 +27226,8 @@ ${lanes.join("\n")}
           return false;
         }
       }
-      function containsIgnoredPath(path10) {
-        return some(ignoredPaths, (p) => path10.includes(p));
+      function containsIgnoredPath(path11) {
+        return some(ignoredPaths, (p) => path11.includes(p));
       }
       function getContainingNodeArray(node) {
         if (!node.parent) return void 0;
@@ -47035,7 +47035,7 @@ ${lanes.join("\n")}
               const typeReferenceDirectives = context.typeReferenceDirectives;
               const libReferenceDirectives = context.libReferenceDirectives;
               forEach(toArray(entryOrList), (arg) => {
-                const { types, lib, path: path10, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
+                const { types, lib, path: path11, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
                 const preserve = _preserve === "true" ? true : void 0;
                 if (arg.arguments["no-default-lib"] === "true") {
                   context.hasNoDefaultLib = true;
@@ -47044,8 +47044,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 (path10) {
-                  referencedFiles.push({ pos: path10.pos, end: path10.end, fileName: path10.value, ...preserve ? { preserve } : {} });
+                } else if (path11) {
+                  referencedFiles.push({ pos: path11.pos, end: path11.end, fileName: path11.value, ...preserve ? { preserve } : {} });
                 } else {
                   reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
                 }
@@ -49474,9 +49474,9 @@ ${lanes.join("\n")}
         if (specs[0] === defaultIncludeSpec) return void 0;
         return specs;
       }
-      function matchesSpecs(path10, includeSpecs, excludeSpecs, host) {
+      function matchesSpecs(path11, includeSpecs, excludeSpecs, host) {
         if (!includeSpecs) return returnTrue;
-        const patterns = getFileMatcherPatterns(path10, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
+        const patterns = getFileMatcherPatterns(path11, 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) {
@@ -50121,9 +50121,9 @@ ${lanes.join("\n")}
             const setPropertyInResultIfNotUndefined = (propertyName) => {
               if (ownConfig.raw[propertyName]) return;
               if (extendsRaw[propertyName]) {
-                result[propertyName] = map(extendsRaw[propertyName], (path10) => startsWithConfigDirTemplate(path10) || isRootedDiskPath(path10) ? path10 : combinePaths(
+                result[propertyName] = map(extendsRaw[propertyName], (path11) => startsWithConfigDirTemplate(path11) || isRootedDiskPath(path11) ? path11 : combinePaths(
                   relativeDifference || (relativeDifference = convertToRelativePath(getDirectoryPath(extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames))),
-                  path10
+                  path11
                 ));
               }
             };
@@ -50277,11 +50277,11 @@ ${lanes.join("\n")}
         return void 0;
       }
       function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache, result) {
-        const path10 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
+        const path11 = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
         let value;
         let extendedResult;
         let extendedConfig;
-        if (extendedConfigCache && (value = extendedConfigCache.get(path10))) {
+        if (extendedConfigCache && (value = extendedConfigCache.get(path11))) {
           ({ extendedResult, extendedConfig } = value);
         } else {
           extendedResult = readJsonConfigFile(extendedConfigPath, (path22) => host.readFile(path22));
@@ -50299,7 +50299,7 @@ ${lanes.join("\n")}
             );
           }
           if (extendedConfigCache) {
-            extendedConfigCache.set(path10, { extendedResult, extendedConfig });
+            extendedConfigCache.set(path11, { extendedResult, extendedConfig });
           }
         }
         if (sourceFile) {
@@ -50567,24 +50567,24 @@ ${lanes.join("\n")}
             }
             const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2);
             if (match) {
-              const { key, path: path10, flags } = match;
+              const { key, path: path11, 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 : path10] = flags;
-                if (existingPath === void 0) wildCardKeyToPath.set(key, path10);
+                wildcardDirectories[existingPath !== void 0 ? existingPath : path11] = flags;
+                if (existingPath === void 0) wildCardKeyToPath.set(key, path11);
                 if (flags === 1) {
                   recursiveKeys.push(key);
                 }
               }
             }
           }
-          for (const path10 in wildcardDirectories) {
-            if (hasProperty(wildcardDirectories, path10)) {
+          for (const path11 in wildcardDirectories) {
+            if (hasProperty(wildcardDirectories, path11)) {
               for (const recursiveKey of recursiveKeys) {
-                const key = toCanonicalKey(path10, useCaseSensitiveFileNames2);
+                const key = toCanonicalKey(path11, useCaseSensitiveFileNames2);
                 if (key !== recursiveKey && containsPath(recursiveKey, key, basePath, !useCaseSensitiveFileNames2)) {
-                  delete wildcardDirectories[path10];
+                  delete wildcardDirectories[path11];
                 }
               }
             }
@@ -50592,8 +50592,8 @@ ${lanes.join("\n")}
         }
         return wildcardDirectories;
       }
-      function toCanonicalKey(path10, useCaseSensitiveFileNames2) {
-        return useCaseSensitiveFileNames2 ? path10 : toFileNameLowerCase(path10);
+      function toCanonicalKey(path11, useCaseSensitiveFileNames2) {
+        return useCaseSensitiveFileNames2 ? path11 : toFileNameLowerCase(path11);
       }
       function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
         const match = wildcardDirectoryPattern.exec(spec);
@@ -50609,10 +50609,10 @@ ${lanes.join("\n")}
           };
         }
         if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
-          const path10 = removeTrailingDirectorySeparator(spec);
+          const path11 = removeTrailingDirectorySeparator(spec);
           return {
-            key: toCanonicalKey(path10, useCaseSensitiveFileNames2),
-            path: path10,
+            key: toCanonicalKey(path11, useCaseSensitiveFileNames2),
+            path: path11,
             flags: 1
             /* Recursive */
           };
@@ -50851,11 +50851,11 @@ ${lanes.join("\n")}
           }
           return;
         }
-        const path10 = normalizePath(combinePaths(baseDirectory, fileName));
+        const path11 = normalizePath(combinePaths(baseDirectory, fileName));
         if (state.traceEnabled) {
-          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path10);
+          trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path11);
         }
-        return path10;
+        return path11;
       }
       function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
         return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
@@ -51369,13 +51369,13 @@ ${lanes.join("\n")}
           directoryToModuleNameMap.update(options2);
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
-          const path10 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path10, () => createModeAwareCache());
+          const path11 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path11, () => createModeAwareCache());
         }
         function getFromDirectoryCache(name, mode, directoryName, redirectedReference) {
           var _a, _b;
-          const path10 = toPath(directoryName, currentDirectory, getCanonicalFileName);
-          return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a.get(path10)) == null ? void 0 : _b.get(name, mode);
+          const path11 = toPath(directoryName, currentDirectory, getCanonicalFileName);
+          return (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a.get(path11)) == null ? void 0 : _b.get(name, mode);
         }
       }
       function createModeAwareCacheKey(specifier, mode) {
@@ -51452,14 +51452,14 @@ ${lanes.join("\n")}
             return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
           }
           function set(directory, result) {
-            const path10 = toPath(directory, currentDirectory, getCanonicalFileName);
-            if (directoryPathMap.has(path10)) {
+            const path11 = toPath(directory, currentDirectory, getCanonicalFileName);
+            if (directoryPathMap.has(path11)) {
               return;
             }
-            directoryPathMap.set(path10, result);
+            directoryPathMap.set(path11, result);
             const resolvedFileName = getResolvedFileName(result);
-            const commonPrefix = resolvedFileName && getCommonPrefix(path10, resolvedFileName);
-            let current = path10;
+            const commonPrefix = resolvedFileName && getCommonPrefix(path11, resolvedFileName);
+            let current = path11;
             while (current !== commonPrefix) {
               const parent2 = getDirectoryPath(current);
               if (parent2 === current || directoryPathMap.has(parent2)) {
@@ -52023,16 +52023,16 @@ ${lanes.join("\n")}
         const combined = combinePaths(containingDirectory, moduleName);
         const parts = getPathComponents(combined);
         const lastPart = lastOrUndefined(parts);
-        const path10 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
-        return { path: path10, parts };
+        const path11 = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
+        return { path: path11, parts };
       }
-      function realPath(path10, host, traceEnabled) {
+      function realPath(path11, host, traceEnabled) {
         if (!host.realpath) {
-          return path10;
+          return path11;
         }
-        const real = normalizePath(host.realpath(path10));
+        const real = normalizePath(host.realpath(path11));
         if (traceEnabled) {
-          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path10, real);
+          trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path11, real);
         }
         return real;
       }
@@ -52077,25 +52077,25 @@ ${lanes.join("\n")}
         return void 0;
       }
       var nodeModulesPathPart = "/node_modules/";
-      function pathContainsNodeModules(path10) {
-        return path10.includes(nodeModulesPathPart);
+      function pathContainsNodeModules(path11) {
+        return path11.includes(nodeModulesPathPart);
       }
       function parseNodeModuleFromPath(resolved, isFolder) {
-        const path10 = normalizePath(resolved);
-        const idx = path10.lastIndexOf(nodeModulesPathPart);
+        const path11 = normalizePath(resolved);
+        const idx = path11.lastIndexOf(nodeModulesPathPart);
         if (idx === -1) {
           return void 0;
         }
         const indexAfterNodeModules = idx + nodeModulesPathPart.length;
-        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path10, indexAfterNodeModules, isFolder);
-        if (path10.charCodeAt(indexAfterNodeModules) === 64) {
-          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path10, indexAfterPackageName, isFolder);
+        let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path11, indexAfterNodeModules, isFolder);
+        if (path11.charCodeAt(indexAfterNodeModules) === 64) {
+          indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path11, indexAfterPackageName, isFolder);
         }
-        return path10.slice(0, indexAfterPackageName);
+        return path11.slice(0, indexAfterPackageName);
       }
-      function moveToNextDirectorySeparatorIfAvailable(path10, prevSeparatorIndex, isFolder) {
-        const nextSeparatorIndex = path10.indexOf(directorySeparator, prevSeparatorIndex + 1);
-        return nextSeparatorIndex === -1 ? isFolder ? path10.length : prevSeparatorIndex : nextSeparatorIndex;
+      function moveToNextDirectorySeparatorIfAvailable(path11, prevSeparatorIndex, isFolder) {
+        const nextSeparatorIndex = path11.indexOf(directorySeparator, prevSeparatorIndex + 1);
+        return nextSeparatorIndex === -1 ? isFolder ? path11.length : prevSeparatorIndex : nextSeparatorIndex;
       }
       function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
         return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
@@ -52237,8 +52237,8 @@ ${lanes.join("\n")}
             return extensions & 4 && !isDeclarationFileName(candidate + originalExtension) && tryExtension(`.d${originalExtension}.ts`) || void 0;
         }
         function tryExtension(ext, resolvedUsingTsExtension) {
-          const path10 = tryFile(candidate + ext, onlyRecordFailures, state);
-          return path10 === void 0 ? void 0 : { path: path10, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
+          const path11 = tryFile(candidate + ext, onlyRecordFailures, state);
+          return path11 === void 0 ? void 0 : { path: path11, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
         }
       }
       function tryFile(fileName, onlyRecordFailures, state) {
@@ -52934,10 +52934,10 @@ ${lanes.join("\n")}
             /*value*/
             void 0
           );
-          function toAbsolutePath(path10) {
+          function toAbsolutePath(path11) {
             var _a2, _b2;
-            if (path10 === void 0) return path10;
-            return getNormalizedAbsolutePath(path10, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
+            if (path11 === void 0) return path11;
+            return getNormalizedAbsolutePath(path11, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
           }
           function combineDirectoryPath(root, dir) {
             return ensureTrailingDirectorySeparator(combinePaths(root, dir));
@@ -53188,10 +53188,10 @@ ${lanes.join("\n")}
             trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
           }
           const resolved = forEach(paths[matchedPatternText], (subst) => {
-            const path10 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
-            const candidate = normalizePath(combinePaths(baseDirectory, path10));
+            const path11 = matchedStar ? replaceFirstStar(subst, matchedStar) : subst;
+            const candidate = normalizePath(combinePaths(baseDirectory, path11));
             if (state.traceEnabled) {
-              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path10);
+              trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path11);
             }
             const extension = tryGetExtensionFromPath2(subst);
             if (extension !== void 0) {
@@ -57344,10 +57344,10 @@ ${lanes.join("\n")}
         if (a === void 0 || b === void 0) return false;
         return comparePaths(a, b, ignoreCase) === 0;
       }
-      function countPathComponents(path10) {
+      function countPathComponents(path11) {
         let count = 0;
-        for (let i = startsWith(path10, "./") ? 2 : 0; i < path10.length; i++) {
-          if (path10.charCodeAt(i) === 47) count++;
+        for (let i = startsWith(path11, "./") ? 2 : 0; i < path11.length; i++) {
+          if (path11.charCodeAt(i) === 47) count++;
         }
         return count;
       }
@@ -57464,9 +57464,9 @@ ${lanes.join("\n")}
           host,
           /*preferSymlinks*/
           true,
-          (path10, isRedirect) => {
-            const isInNodeModules = pathContainsNodeModules(path10);
-            allFileNames.set(path10, { path: info.getCanonicalFileName(path10), isRedirect, isInNodeModules });
+          (path11, isRedirect) => {
+            const isInNodeModules = pathContainsNodeModules(path11);
+            allFileNames.set(path11, { path: info.getCanonicalFileName(path11), isRedirect, isInNodeModules });
             importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
           }
         );
@@ -57474,8 +57474,8 @@ ${lanes.join("\n")}
         for (let directory = info.canonicalSourceDirectory; allFileNames.size !== 0; ) {
           const directoryStart = ensureTrailingDirectorySeparator(directory);
           let pathsInDirectory;
-          allFileNames.forEach(({ path: path10, isRedirect, isInNodeModules }, fileName) => {
-            if (startsWith(path10, directoryStart)) {
+          allFileNames.forEach(({ path: path11, isRedirect, isInNodeModules }, fileName) => {
+            if (startsWith(path11, directoryStart)) {
               (pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect, isInNodeModules });
               allFileNames.delete(fileName);
             }
@@ -57778,17 +57778,17 @@ ${lanes.join("\n")}
         }
         return processEnding(shortest, allowedEndings, compilerOptions);
       }
-      function tryGetModuleNameAsNodeModule({ path: path10, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
+      function tryGetModuleNameAsNodeModule({ path: path11, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
         if (!host.fileExists || !host.readFile) {
           return void 0;
         }
-        const parts = getNodeModulePathParts(path10);
+        const parts = getNodeModulePathParts(path11);
         if (!parts) {
           return void 0;
         }
         const preferences = getModuleSpecifierPreferences(userPreferences, host, options, importingSourceFile);
         const allowedEndings = preferences.getAllowedEndingsInPreferredOrder();
-        let moduleSpecifier = path10;
+        let moduleSpecifier = path11;
         let isPackageRootPath = false;
         if (!packageNameOnly) {
           let packageRootIndex = parts.packageRootIndex;
@@ -57809,7 +57809,7 @@ ${lanes.join("\n")}
               break;
             }
             if (!moduleFileName) moduleFileName = moduleFileToTry;
-            packageRootIndex = path10.indexOf(directorySeparator, packageRootIndex + 1);
+            packageRootIndex = path11.indexOf(directorySeparator, packageRootIndex + 1);
             if (packageRootIndex === -1) {
               moduleSpecifier = processEnding(moduleFileName, allowedEndings, options, host);
               break;
@@ -57829,9 +57829,9 @@ ${lanes.join("\n")}
         return getEmitModuleResolutionKind(options) === 1 && packageName === nodeModulesDirectoryName ? void 0 : packageName;
         function tryDirectoryWithPackageJson(packageRootIndex) {
           var _a, _b;
-          const packageRootPath = path10.substring(0, packageRootIndex);
+          const packageRootPath = path11.substring(0, packageRootIndex);
           const packageJsonPath = combinePaths(packageRootPath, "package.json");
-          let moduleFileToTry = path10;
+          let moduleFileToTry = path11;
           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)) {
@@ -57844,7 +57844,7 @@ ${lanes.join("\n")}
               const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(
                 options,
                 host,
-                path10,
+                path11,
                 packageRootPath,
                 packageName2,
                 packageJsonContent.exports,
@@ -57854,12 +57854,12 @@ ${lanes.join("\n")}
                 return { ...fromExports, verbatimFromExports: true };
               }
               if (packageJsonContent == null ? void 0 : packageJsonContent.exports) {
-                return { moduleFileToTry: path10, blockedByExports: true };
+                return { moduleFileToTry: path11, blockedByExports: true };
               }
             }
             const versionPaths = (packageJsonContent == null ? void 0 : packageJsonContent.typesVersions) ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
             if (versionPaths) {
-              const subModuleName = path10.slice(packageRootPath.length + 1);
+              const subModuleName = path11.slice(packageRootPath.length + 1);
               const fromPaths = tryGetModuleNameFromPaths(
                 subModuleName,
                 versionPaths.paths,
@@ -57894,7 +57894,7 @@ ${lanes.join("\n")}
           return { moduleFileToTry };
         }
       }
-      function tryGetAnyFileFromPath(host, path10) {
+      function tryGetAnyFileFromPath(host, path11) {
         if (!host.fileExists) return;
         const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, {
           extension: "json",
@@ -57903,15 +57903,15 @@ ${lanes.join("\n")}
           /* JSON */
         }]));
         for (const e of extensions) {
-          const fullPath = path10 + e;
+          const fullPath = path11 + e;
           if (host.fileExists(fullPath)) {
             return fullPath;
           }
         }
       }
-      function getPathsRelativeToRootDirs(path10, rootDirs, getCanonicalFileName) {
+      function getPathsRelativeToRootDirs(path11, rootDirs, getCanonicalFileName) {
         return mapDefined(rootDirs, (rootDir) => {
-          const relativePath = getRelativePathIfInSameVolume(path10, rootDir, getCanonicalFileName);
+          const relativePath = getRelativePathIfInSameVolume(path11, rootDir, getCanonicalFileName);
           return relativePath !== void 0 && isPathRelativeToParent(relativePath) ? void 0 : relativePath;
         });
       }
@@ -58028,10 +58028,10 @@ ${lanes.join("\n")}
             return void 0;
         }
       }
-      function getRelativePathIfInSameVolume(path10, directoryPath, getCanonicalFileName) {
+      function getRelativePathIfInSameVolume(path11, directoryPath, getCanonicalFileName) {
         const relativePath = getRelativePathToDirectoryOrUrl(
           directoryPath,
-          path10,
+          path11,
           directoryPath,
           getCanonicalFileName,
           /*isAbsolutePathAnUrl*/
@@ -58039,8 +58039,8 @@ ${lanes.join("\n")}
         );
         return isRootedDiskPath(relativePath) ? void 0 : relativePath;
       }
-      function isPathRelativeToParent(path10) {
-        return startsWith(path10, "..");
+      function isPathRelativeToParent(path11) {
+        return startsWith(path11, "..");
       }
       function getDefaultResolutionModeForFile(file, host, compilerOptions) {
         return isFullSourceFile(file) ? host.getDefaultResolutionModeForFile(file) : getDefaultResolutionModeForFileWorker(file, compilerOptions);
@@ -73089,10 +73089,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 path10 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
-            let result = unresolvedSymbols.get(path10);
+            const path11 = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
+            let result = unresolvedSymbols.get(path11);
             if (!result) {
-              unresolvedSymbols.set(path10, result = createSymbol(
+              unresolvedSymbols.set(path11, result = createSymbol(
                 524288,
                 text,
                 1048576
@@ -77893,24 +77893,24 @@ ${lanes.join("\n")}
               }
               return;
             }
-            let path10 = "";
+            let path11 = "";
             const secondaryRootErrors = [];
             while (stack.length) {
               const [msg, ...args] = stack.pop();
               switch (msg.code) {
                 case Diagnostics.Types_of_property_0_are_incompatible.code: {
-                  if (path10.indexOf("new ") === 0) {
-                    path10 = `(${path10})`;
+                  if (path11.indexOf("new ") === 0) {
+                    path11 = `(${path11})`;
                   }
                   const str = "" + args[0];
-                  if (path10.length === 0) {
-                    path10 = `${str}`;
+                  if (path11.length === 0) {
+                    path11 = `${str}`;
                   } else if (isIdentifierText(str, getEmitScriptTarget(compilerOptions))) {
-                    path10 = `${path10}.${str}`;
+                    path11 = `${path11}.${str}`;
                   } else if (str[0] === "[" && str[str.length - 1] === "]") {
-                    path10 = `${path10}${str}`;
+                    path11 = `${path11}${str}`;
                   } else {
-                    path10 = `${path10}[${str}]`;
+                    path11 = `${path11}[${str}]`;
                   }
                   break;
                 }
@@ -77918,7 +77918,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 (path10.length === 0) {
+                  if (path11.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;
@@ -77929,7 +77929,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 ? "" : "...";
-                    path10 = `${prefix}${path10}(${params})`;
+                    path11 = `${prefix}${path11}(${params})`;
                   }
                   break;
                 }
@@ -77945,10 +77945,10 @@ ${lanes.join("\n")}
                   return Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
               }
             }
-            if (path10) {
+            if (path11) {
               reportError(
-                path10[path10.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
-                path10
+                path11[path11.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
+                path11
               );
             } else {
               secondaryRootErrors.shift();
@@ -133016,9 +133016,9 @@ ${lanes.join("\n")}
       function createAddOutput() {
         let outputs;
         return { addOutput, getOutputs };
-        function addOutput(path10) {
-          if (path10) {
-            (outputs || (outputs = [])).push(path10);
+        function addOutput(path11) {
+          if (path11) {
+            (outputs || (outputs = [])).push(path11);
           }
         }
         function getOutputs() {
@@ -138244,7 +138244,7 @@ ${lanes.join("\n")}
         return {
           useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
           fileExists,
-          readFile: (path10, encoding) => host.readFile(path10, encoding),
+          readFile: (path11, encoding) => host.readFile(path11, encoding),
           directoryExists: host.directoryExists && directoryExists,
           getDirectories,
           readDirectory,
@@ -138261,8 +138261,8 @@ ${lanes.join("\n")}
         function getCachedFileSystemEntries(rootDirPath) {
           return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
         }
-        function getCachedFileSystemEntriesForBaseDir(path10) {
-          const entries = getCachedFileSystemEntries(getDirectoryPath(path10));
+        function getCachedFileSystemEntriesForBaseDir(path11) {
+          const entries = getCachedFileSystemEntries(getDirectoryPath(path11));
           if (!entries) {
             return entries;
           }
@@ -138317,8 +138317,8 @@ ${lanes.join("\n")}
           return index >= 0;
         }
         function writeFile22(fileName, data, writeByteOrderMark) {
-          const path10 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path10);
+          const path11 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path11);
           if (result) {
             updateFilesOfFileSystemEntry(
               result,
@@ -138330,17 +138330,17 @@ ${lanes.join("\n")}
           return host.writeFile(fileName, data, writeByteOrderMark);
         }
         function fileExists(fileName) {
-          const path10 = toPath3(fileName);
-          const result = getCachedFileSystemEntriesForBaseDir(path10);
+          const path11 = toPath3(fileName);
+          const result = getCachedFileSystemEntriesForBaseDir(path11);
           return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || host.fileExists(fileName);
         }
         function directoryExists(dirPath) {
-          const path10 = toPath3(dirPath);
-          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path10)) || host.directoryExists(dirPath);
+          const path11 = toPath3(dirPath);
+          return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path11)) || host.directoryExists(dirPath);
         }
         function createDirectory(dirPath) {
-          const path10 = toPath3(dirPath);
-          const result = getCachedFileSystemEntriesForBaseDir(path10);
+          const path11 = toPath3(dirPath);
+          const result = getCachedFileSystemEntriesForBaseDir(path11);
           if (result) {
             const baseName = getBaseNameOfFileName(dirPath);
             const canonicalizedBaseName = getCanonicalFileName(baseName);
@@ -138368,15 +138368,15 @@ ${lanes.join("\n")}
           }
           return host.readDirectory(rootDir, extensions, excludes, includes, depth);
           function getFileSystemEntries(dir) {
-            const path10 = toPath3(dir);
-            if (path10 === rootDirPath) {
-              return rootResult || getFileSystemEntriesFromHost(dir, path10);
+            const path11 = toPath3(dir);
+            if (path11 === rootDirPath) {
+              return rootResult || getFileSystemEntriesFromHost(dir, path11);
             }
-            const result = tryReadDirectory2(dir, path10);
-            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path10) : emptyFileSystemEntries;
+            const result = tryReadDirectory2(dir, path11);
+            return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path11) : emptyFileSystemEntries;
           }
-          function getFileSystemEntriesFromHost(dir, path10) {
-            if (rootSymLinkResult && path10 === rootDirPath) return rootSymLinkResult;
+          function getFileSystemEntriesFromHost(dir, path11) {
+            if (rootSymLinkResult && path11 === rootDirPath) return rootSymLinkResult;
             const result = {
               files: map(host.readDirectory(
                 dir,
@@ -138389,7 +138389,7 @@ ${lanes.join("\n")}
               ), getBaseNameOfFileName) || emptyArray,
               directories: host.getDirectories(dir) || emptyArray
             };
-            if (path10 === rootDirPath) rootSymLinkResult = result;
+            if (path11 === rootDirPath) rootSymLinkResult = result;
             return result;
           }
         }
@@ -138848,15 +138848,15 @@ ${lanes.join("\n")}
           return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
         }
         const newLine = getNewLineCharacter(options);
-        const realpath = system.realpath && ((path10) => system.realpath(path10));
+        const realpath = system.realpath && ((path11) => system.realpath(path11));
         const compilerHost = {
           getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), setParentNodes),
           getDefaultLibLocation,
           getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
           writeFile: createWriteFileMeasuringIO(
-            (path10, data, writeByteOrderMark) => system.writeFile(path10, data, writeByteOrderMark),
-            (path10) => (compilerHost.createDirectory || system.createDirectory)(path10),
-            (path10) => directoryExists(path10)
+            (path11, data, writeByteOrderMark) => system.writeFile(path11, data, writeByteOrderMark),
+            (path11) => (compilerHost.createDirectory || system.createDirectory)(path11),
+            (path11) => directoryExists(path11)
           ),
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
@@ -138867,9 +138867,9 @@ ${lanes.join("\n")}
           trace: (s) => system.write(s + newLine),
           directoryExists: (directoryName) => system.directoryExists(directoryName),
           getEnvironmentVariable: (name) => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",
-          getDirectories: (path10) => system.getDirectories(path10),
+          getDirectories: (path11) => system.getDirectories(path11),
           realpath,
-          readDirectory: (path10, extensions, include, exclude, depth) => system.readDirectory(path10, extensions, include, exclude, depth),
+          readDirectory: (path11, extensions, include, exclude, depth) => system.readDirectory(path11, extensions, include, exclude, depth),
           createDirectory: (d) => system.createDirectory(d),
           createHash: maybeBind(system, system.createHash)
         };
@@ -139308,13 +139308,13 @@ ${lanes.join("\n")}
       }
       function getLibraryNameFromLibFileName(libFileName) {
         const components = libFileName.split(".");
-        let path10 = components[1];
+        let path11 = components[1];
         let i = 2;
         while (components[i] && components[i] !== "d") {
-          path10 += (i === 2 ? "/" : "-") + components[i];
+          path11 += (i === 2 ? "/" : "-") + components[i];
           i++;
         }
-        return "@typescript/lib-" + path10;
+        return "@typescript/lib-" + path11;
       }
       function isReferencedFile(reason) {
         switch (reason == null ? void 0 : reason.kind) {
@@ -140390,18 +140390,18 @@ ${lanes.join("\n")}
             filesByName.set(newSourceFile.path, newSourceFile);
           }
           const oldFilesByNameMap = oldProgram.getFilesByNameMap();
-          oldFilesByNameMap.forEach((oldFile, path10) => {
+          oldFilesByNameMap.forEach((oldFile, path11) => {
             if (!oldFile) {
-              filesByName.set(path10, oldFile);
+              filesByName.set(path11, oldFile);
               return;
             }
-            if (oldFile.path === path10) {
+            if (oldFile.path === path11) {
               if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) {
                 sourceFilesFoundSearchingNodeModules.set(oldFile.path, true);
               }
               return;
             }
-            filesByName.set(path10, filesByName.get(oldFile.path));
+            filesByName.set(path11, 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);
@@ -140439,9 +140439,9 @@ ${lanes.join("\n")}
             getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
             readFile: (f) => host.readFile(f),
             fileExists: (f) => {
-              const path10 = toPath3(f);
-              if (getSourceFileByPath(path10)) return true;
-              if (missingFileNames.has(path10)) return false;
+              const path11 = toPath3(f);
+              if (getSourceFileByPath(path11)) return true;
+              if (missingFileNames.has(path11)) return false;
               return host.fileExists(f);
             },
             realpath: maybeBind(host, host.realpath),
@@ -140581,8 +140581,8 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           return getSourceFileByPath(toPath3(fileName));
         }
-        function getSourceFileByPath(path10) {
-          return filesByName.get(path10) || void 0;
+        function getSourceFileByPath(path11) {
+          return filesByName.get(path11) || void 0;
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics2, cancellationToken) {
           if (sourceFile) {
@@ -141225,16 +141225,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, path10, resolvedPath, originalFileName, sourceFileOptions) {
+        function createRedirectedSourceFile(redirectTarget, unredirected, fileName, path11, resolvedPath, originalFileName, sourceFileOptions) {
           var _a2;
           const redirect = parseNodeFactory.createRedirectedSourceFile({ redirectTarget, unredirected });
           redirect.fileName = fileName;
-          redirect.path = path10;
+          redirect.path = path11;
           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(path10, currentNodeModulesDepth > 0);
+          sourceFilesFoundSearchingNodeModules.set(path11, currentNodeModulesDepth > 0);
           return redirect;
         }
         function findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
@@ -141256,18 +141256,18 @@ ${lanes.join("\n")}
         }
         function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
           var _a2, _b2;
-          const path10 = toPath3(fileName);
+          const path11 = toPath3(fileName);
           if (useSourceOfProjectReferenceRedirect) {
-            let source = getRedirectFromOutput(path10);
+            let source = getRedirectFromOutput(path11);
             if (!source && host.realpath && options.preserveSymlinks && isDeclarationFileName(fileName) && fileName.includes(nodeModulesPathPart)) {
               const realPath2 = toPath3(host.realpath(fileName));
-              if (realPath2 !== path10) source = getRedirectFromOutput(realPath2);
+              if (realPath2 !== path11) source = getRedirectFromOutput(realPath2);
             }
             if (source == null ? void 0 : source.source) {
               const file2 = findSourceFile(source.source, isDefaultLib, ignoreNoDefaultLib, reason, packageId);
               if (file2) addFileToFilesByName(
                 file2,
-                path10,
+                path11,
                 fileName,
                 /*redirectedPath*/
                 void 0
@@ -141276,8 +141276,8 @@ ${lanes.join("\n")}
             }
           }
           const originalFileName = fileName;
-          if (filesByName.has(path10)) {
-            const file2 = filesByName.get(path10);
+          if (filesByName.has(path11)) {
+            const file2 = filesByName.get(path11);
             const addedReason = addFileIncludeReason(
               file2 || void 0,
               reason,
@@ -141343,28 +141343,28 @@ ${lanes.join("\n")}
             const packageIdKey = packageIdToString(packageId);
             const fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
             if (fileFromPackageId) {
-              const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path10, toPath3(fileName), originalFileName, sourceFileOptions);
+              const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path11, toPath3(fileName), originalFileName, sourceFileOptions);
               redirectTargetsMap.add(fileFromPackageId.path, fileName);
-              addFileToFilesByName(dupFile, path10, fileName, redirectedPath);
+              addFileToFilesByName(dupFile, path11, fileName, redirectedPath);
               addFileIncludeReason(
                 dupFile,
                 reason,
                 /*checkExisting*/
                 false
               );
-              sourceFileToPackageName.set(path10, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path11, packageIdToPackageName(packageId));
               processingOtherFiles.push(dupFile);
               return dupFile;
             } else if (file) {
               packageIdToSourceFile.set(packageIdKey, file);
-              sourceFileToPackageName.set(path10, packageIdToPackageName(packageId));
+              sourceFileToPackageName.set(path11, packageIdToPackageName(packageId));
             }
           }
-          addFileToFilesByName(file, path10, fileName, redirectedPath);
+          addFileToFilesByName(file, path11, fileName, redirectedPath);
           if (file) {
-            sourceFilesFoundSearchingNodeModules.set(path10, currentNodeModulesDepth > 0);
+            sourceFilesFoundSearchingNodeModules.set(path11, currentNodeModulesDepth > 0);
             file.fileName = fileName;
-            file.path = path10;
+            file.path = path11;
             file.resolvedPath = toPath3(fileName);
             file.originalFileName = originalFileName;
             file.packageJsonLocations = ((_b2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _b2.length) ? sourceFileOptions.packageJsonLocations : void 0;
@@ -141376,7 +141376,7 @@ ${lanes.join("\n")}
               false
             );
             if (host.useCaseSensitiveFileNames()) {
-              const pathLowerCase = toFileNameLowerCase(path10);
+              const pathLowerCase = toFileNameLowerCase(path11);
               const existingFile = filesByNameIgnoreCase.get(pathLowerCase);
               if (existingFile) {
                 reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason);
@@ -141409,18 +141409,18 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function addFileToFilesByName(file, path10, fileName, redirectedPath) {
+        function addFileToFilesByName(file, path11, fileName, redirectedPath) {
           if (redirectedPath) {
             updateFilesByNameMap(fileName, redirectedPath, file);
-            updateFilesByNameMap(fileName, path10, file || false);
+            updateFilesByNameMap(fileName, path11, file || false);
           } else {
-            updateFilesByNameMap(fileName, path10, file);
+            updateFilesByNameMap(fileName, path11, file);
           }
         }
-        function updateFilesByNameMap(fileName, path10, file) {
-          filesByName.set(path10, file);
-          if (file !== void 0) missingFileNames.delete(path10);
-          else missingFileNames.set(path10, fileName);
+        function updateFilesByNameMap(fileName, path11, file) {
+          filesByName.set(path11, file);
+          if (file !== void 0) missingFileNames.delete(path11);
+          else missingFileNames.set(path11, fileName);
         }
         function getRedirectFromSourceFile(fileName) {
           return mapSourceFileToResolvedRef == null ? void 0 : mapSourceFileToResolvedRef.get(toPath3(fileName));
@@ -141428,8 +141428,8 @@ ${lanes.join("\n")}
         function forEachResolvedProjectReference2(cb) {
           return forEachResolvedProjectReference(resolvedProjectReferences, cb);
         }
-        function getRedirectFromOutput(path10) {
-          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path10);
+        function getRedirectFromOutput(path11) {
+          return mapOutputFileToResolvedRef == null ? void 0 : mapOutputFileToResolvedRef.get(path11);
         }
         function isSourceOfProjectReferenceRedirect(fileName) {
           return useSourceOfProjectReferenceRedirect && !!getRedirectFromSourceFile(fileName);
@@ -141728,7 +141728,7 @@ ${lanes.join("\n")}
             }
             const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()));
             commandLine.fileNames.forEach((fileName) => {
-              const path10 = toPath3(fileName);
+              const path11 = toPath3(fileName);
               let outputDts;
               if (!isDeclarationFileName(fileName) && !fileExtensionIs(
                 fileName,
@@ -141742,7 +141742,7 @@ ${lanes.join("\n")}
                   outputDts = outDts;
                 }
               }
-              mapSourceFileToResolvedRef.set(path10, { resolvedRef, outputDts });
+              mapSourceFileToResolvedRef.set(path11, { resolvedRef, outputDts });
             });
           }
           if (commandLine.projectReferences) {
@@ -142430,9 +142430,9 @@ ${lanes.join("\n")}
         host.compilerHost.fileExists = fileExists;
         let directoryExists;
         if (originalDirectoryExists) {
-          directoryExists = host.compilerHost.directoryExists = (path10) => {
-            if (originalDirectoryExists.call(host.compilerHost, path10)) {
-              handleDirectoryCouldBeSymlink(path10);
+          directoryExists = host.compilerHost.directoryExists = (path11) => {
+            if (originalDirectoryExists.call(host.compilerHost, path11)) {
+              handleDirectoryCouldBeSymlink(path11);
               return true;
             }
             if (!host.getResolvedProjectReferences()) return false;
@@ -142451,14 +142451,14 @@ ${lanes.join("\n")}
               });
             }
             return fileOrDirectoryExistsUsingSource(
-              path10,
+              path11,
               /*isFile*/
               false
             );
           };
         }
         if (originalGetDirectories) {
-          host.compilerHost.getDirectories = (path10) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path10) ? originalGetDirectories.call(host.compilerHost, path10) : [];
+          host.compilerHost.getDirectories = (path11) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path11) ? originalGetDirectories.call(host.compilerHost, path11) : [];
         }
         if (originalRealpath) {
           host.compilerHost.realpath = (s) => {
@@ -143125,12 +143125,12 @@ ${lanes.join("\n")}
           state.allFileNames = void 0;
         }
         BuilderState2.releaseCache = releaseCache2;
-        function getFilesAffectedBy(state, programOfThisState, path10, cancellationToken, host) {
+        function getFilesAffectedBy(state, programOfThisState, path11, cancellationToken, host) {
           var _a;
           const result = getFilesAffectedByWithOldState(
             state,
             programOfThisState,
-            path10,
+            path11,
             cancellationToken,
             host
           );
@@ -143138,8 +143138,8 @@ ${lanes.join("\n")}
           return result;
         }
         BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path10, cancellationToken, host) {
-          const sourceFile = programOfThisState.getSourceFileByPath(path10);
+        function getFilesAffectedByWithOldState(state, programOfThisState, path11, cancellationToken, host) {
+          const sourceFile = programOfThisState.getSourceFileByPath(path11);
           if (!sourceFile) {
             return emptyArray;
           }
@@ -143149,9 +143149,9 @@ ${lanes.join("\n")}
           return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
         }
         BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
-        function updateSignatureOfFile(state, signature, path10) {
-          state.fileInfos.get(path10).signature = signature;
-          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path10);
+        function updateSignatureOfFile(state, signature, path11) {
+          state.fileInfos.get(path11).signature = signature;
+          (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path11);
         }
         BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
         function computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, onNewSignature) {
@@ -143220,10 +143220,10 @@ ${lanes.join("\n")}
           const seenMap = /* @__PURE__ */ new Set();
           const queue = [sourceFile.resolvedPath];
           while (queue.length) {
-            const path10 = queue.pop();
-            if (!seenMap.has(path10)) {
-              seenMap.add(path10);
-              const references = state.referencedMap.getValues(path10);
+            const path11 = queue.pop();
+            if (!seenMap.has(path11)) {
+              seenMap.add(path11);
+              const references = state.referencedMap.getValues(path11);
               if (references) {
                 for (const key of references.keys()) {
                   queue.push(key);
@@ -143231,9 +143231,9 @@ ${lanes.join("\n")}
               }
             }
           }
-          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path10) => {
+          return arrayFrom(mapDefinedIterator(seenMap.keys(), (path11) => {
             var _a;
-            return ((_a = programOfThisState.getSourceFileByPath(path10)) == null ? void 0 : _a.fileName) ?? path10;
+            return ((_a = programOfThisState.getSourceFileByPath(path11)) == null ? void 0 : _a.fileName) ?? path11;
           }));
         }
         BuilderState2.getAllDependencies = getAllDependencies;
@@ -143412,7 +143412,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, (path10) => !state.fileInfos.has(path10) && oldState.fileInfos.has(path10))) {
+          newReferences && forEachKey(newReferences, (path11) => !state.fileInfos.has(path11) && oldState.fileInfos.has(path11))) {
             addFileToChangeSet(sourceFilePath);
           } else {
             const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
@@ -143478,8 +143478,8 @@ ${lanes.join("\n")}
         }
         if (useOldState && state.semanticDiagnosticsPerFile.size !== state.fileInfos.size && oldState.checkPending !== state.checkPending) state.buildInfoEmitPending = true;
         return state;
-        function addFileToChangeSet(path10) {
-          state.changedFilesSet.add(path10);
+        function addFileToChangeSet(path11) {
+          state.changedFilesSet.add(path11);
           if (outFilePath) {
             canCopySemanticDiagnostics = false;
             canCopyEmitDiagnostics = false;
@@ -143543,9 +143543,9 @@ ${lanes.join("\n")}
           result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, diagnosticFilePath, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
           return result;
         });
-        function toPathInBuildInfoDirectory(path10) {
+        function toPathInBuildInfoDirectory(path11) {
           buildInfoDirectory ?? (buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())));
-          return toPath(path10, buildInfoDirectory, newProgram.getCanonicalFileName);
+          return toPath(path11, buildInfoDirectory, newProgram.getCanonicalFileName);
         }
       }
       function convertToDiagnosticRelatedInformation(diagnostic, diagnosticFilePath, newProgram, toPath3) {
@@ -143620,10 +143620,10 @@ ${lanes.join("\n")}
           state.affectedFilesPendingEmit = void 0;
           state.programEmitPending = void 0;
         }
-        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path10) => {
+        (_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.forEach((emitKind, path11) => {
           const pending = !isForDtsErrors ? emitKind & 7 : emitKind & (7 | 48);
-          if (!pending) state.affectedFilesPendingEmit.delete(path10);
-          else state.affectedFilesPendingEmit.set(path10, pending);
+          if (!pending) state.affectedFilesPendingEmit.delete(path11);
+          else state.affectedFilesPendingEmit.set(path11, pending);
         });
         if (state.programEmitPending) {
           const pending = !isForDtsErrors ? state.programEmitPending & 7 : state.programEmitPending & (7 | 48);
@@ -143643,11 +143643,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, path10) => {
+        return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path11) => {
           var _a2;
-          const affectedFile = state.program.getSourceFileByPath(path10);
+          const affectedFile = state.program.getSourceFileByPath(path11);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.affectedFilesPendingEmit.delete(path10);
+            state.affectedFilesPendingEmit.delete(path11);
             return void 0;
           }
           const seenKind = (_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath);
@@ -143663,11 +143663,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, path10) => {
+        return forEachEntry(state.emitDiagnosticsPerFile, (diagnostics, path11) => {
           var _a2;
-          const affectedFile = state.program.getSourceFileByPath(path10);
+          const affectedFile = state.program.getSourceFileByPath(path11);
           if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
-            state.emitDiagnosticsPerFile.delete(path10);
+            state.emitDiagnosticsPerFile.delete(path11);
             return void 0;
           }
           const seenKind = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedFile.resolvedPath)) || 0;
@@ -143702,10 +143702,10 @@ ${lanes.join("\n")}
           host
         );
       }
-      function handleDtsMayChangeOf(state, path10, invalidateJsFiles, cancellationToken, host) {
-        removeSemanticDiagnosticsOf(state, path10);
-        if (!state.changedFilesSet.has(path10)) {
-          const sourceFile = state.program.getSourceFileByPath(path10);
+      function handleDtsMayChangeOf(state, path11, invalidateJsFiles, cancellationToken, host) {
+        removeSemanticDiagnosticsOf(state, path11);
+        if (!state.changedFilesSet.has(path11)) {
+          const sourceFile = state.program.getSourceFileByPath(path11);
           if (sourceFile) {
             BuilderState.updateShapeSignature(
               state,
@@ -143719,13 +143719,13 @@ ${lanes.join("\n")}
             if (invalidateJsFiles) {
               addToAffectedFilesPendingEmit(
                 state,
-                path10,
+                path11,
                 getBuilderFileEmit(state.compilerOptions)
               );
             } else if (getEmitDeclarations(state.compilerOptions)) {
               addToAffectedFilesPendingEmit(
                 state,
-                path10,
+                path11,
                 state.compilerOptions.declarationMap ? 56 : 24
                 /* Dts */
               );
@@ -143733,17 +143733,17 @@ ${lanes.join("\n")}
           }
         }
       }
-      function removeSemanticDiagnosticsOf(state, path10) {
+      function removeSemanticDiagnosticsOf(state, path11) {
         if (!state.semanticDiagnosticsFromOldState) {
           return true;
         }
-        state.semanticDiagnosticsFromOldState.delete(path10);
-        state.semanticDiagnosticsPerFile.delete(path10);
+        state.semanticDiagnosticsFromOldState.delete(path11);
+        state.semanticDiagnosticsPerFile.delete(path11);
         return !state.semanticDiagnosticsFromOldState.size;
       }
-      function isChangedSignature(state, path10) {
-        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path10) || void 0;
-        const newSignature = Debug.checkDefined(state.fileInfos.get(path10)).signature;
+      function isChangedSignature(state, path11) {
+        const oldSignature = Debug.checkDefined(state.oldSignatures).get(path11) || void 0;
+        const newSignature = Debug.checkDefined(state.fileInfos.get(path11)).signature;
         return newSignature !== oldSignature;
       }
       function handleDtsMayChangeOfGlobalScope(state, filePath, invalidateJsFiles, cancellationToken, host) {
@@ -143850,13 +143850,13 @@ ${lanes.join("\n")}
       }
       function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken, semanticDiagnosticsPerFile) {
         semanticDiagnosticsPerFile ?? (semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile);
-        const path10 = sourceFile.resolvedPath;
-        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path10);
+        const path11 = sourceFile.resolvedPath;
+        const cachedDiagnostics = semanticDiagnosticsPerFile.get(path11);
         if (cachedDiagnostics) {
           return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);
         }
         const diagnostics = state.program.getBindAndCheckDiagnostics(sourceFile, cancellationToken);
-        semanticDiagnosticsPerFile.set(path10, diagnostics);
+        semanticDiagnosticsPerFile.set(path11, diagnostics);
         state.buildInfoEmitPending = true;
         return filterSemanticDiagnostics(diagnostics, state.compilerOptions);
       }
@@ -144004,11 +144004,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 path10 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
-            if (tryAddToSet(seenFiles, path10)) {
-              const file = state.program.getSourceFileByPath(path10);
+          for (const path11 of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
+            if (tryAddToSet(seenFiles, path11)) {
+              const file = state.program.getSourceFileByPath(path11);
               if (!file || !sourceFileMayBeEmitted(file, state.program)) continue;
-              const fileId = toFileId(path10), pendingEmit = state.affectedFilesPendingEmit.get(path10);
+              const fileId = toFileId(path11), pendingEmit = state.affectedFilesPendingEmit.get(path11);
               affectedFilesPendingEmit = append(
                 affectedFilesPendingEmit,
                 pendingEmit === fullEmitForOptions ? fileId : (
@@ -144042,17 +144042,17 @@ ${lanes.join("\n")}
           version
         };
         return buildInfo;
-        function relativeToBuildInfoEnsuringAbsolutePath(path10) {
-          return relativeToBuildInfo(getNormalizedAbsolutePath(path10, currentDirectory));
+        function relativeToBuildInfoEnsuringAbsolutePath(path11) {
+          return relativeToBuildInfo(getNormalizedAbsolutePath(path11, currentDirectory));
         }
-        function relativeToBuildInfo(path10) {
-          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path10, state.program.getCanonicalFileName));
+        function relativeToBuildInfo(path11) {
+          return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path11, state.program.getCanonicalFileName));
         }
-        function toFileId(path10) {
-          let fileId = fileNameToFileId.get(path10);
+        function toFileId(path11) {
+          let fileId = fileNameToFileId.get(path11);
           if (fileId === void 0) {
-            fileNames.push(relativeToBuildInfo(path10));
-            fileNameToFileId.set(path10, fileId = fileNames.length);
+            fileNames.push(relativeToBuildInfo(path11));
+            fileNameToFileId.set(path11, fileId = fileNames.length);
           }
           return fileId;
         }
@@ -144066,8 +144066,8 @@ ${lanes.join("\n")}
           }
           return fileIdListId;
         }
-        function tryAddRoot(path10, fileId) {
-          const file = state.program.getSourceFile(path10);
+        function tryAddRoot(path11, fileId) {
+          const file = state.program.getSourceFile(path11);
           if (!state.program.getFileIncludeReasons().get(file.path).some(
             (r) => r.kind === 0
             /* RootFile */
@@ -144084,10 +144084,10 @@ ${lanes.join("\n")}
         }
         function toResolvedRoot() {
           let result;
-          rootFileNames.forEach((path10) => {
-            const file = state.program.getSourceFileByPath(path10);
-            if (file && path10 !== file.resolvedPath) {
-              result = append(result, [toFileId(file.resolvedPath), toFileId(path10)]);
+          rootFileNames.forEach((path11) => {
+            const file = state.program.getSourceFileByPath(path11);
+            if (file && path11 !== file.resolvedPath) {
+              result = append(result, [toFileId(file.resolvedPath), toFileId(path11)]);
             }
           });
           return result;
@@ -144195,8 +144195,8 @@ ${lanes.join("\n")}
         function toChangeFileSet() {
           let changeFileSet;
           if (state.changedFilesSet.size) {
-            for (const path10 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
-              changeFileSet = append(changeFileSet, toFileId(path10));
+            for (const path11 of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
+              changeFileSet = append(changeFileSet, toFileId(path11));
             }
           }
           return changeFileSet;
@@ -144695,8 +144695,8 @@ ${lanes.join("\n")}
         const changedFilesSet = new Set(map(buildInfo.changeFileSet, toFilePath));
         if (isIncrementalBundleEmitBuildInfo(buildInfo)) {
           buildInfo.fileInfos.forEach((fileInfo, index) => {
-            const path10 = toFilePath(index + 1);
-            fileInfos.set(path10, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
+            const path11 = toFilePath(index + 1);
+            fileInfos.set(path11, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
           });
           state = {
             fileInfos,
@@ -144715,10 +144715,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 path10 = toFilePath(index + 1);
+            const path11 = toFilePath(index + 1);
             const stateFileInfo = toBuilderStateFileInfoForMultiEmit(fileInfo);
-            fileInfos.set(path10, stateFileInfo);
-            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path10, stateFileInfo.signature);
+            fileInfos.set(path11, stateFileInfo);
+            if (emitSignatures && stateFileInfo.signature) emitSignatures.set(path11, stateFileInfo.signature);
           });
           (_d = buildInfo.emitSignatures) == null ? void 0 : _d.forEach((value) => {
             if (isNumber(value)) emitSignatures.delete(toFilePath(value));
@@ -144772,11 +144772,11 @@ ${lanes.join("\n")}
           close: noop,
           hasChangedEmitSignature: returnFalse
         };
-        function toPathInBuildInfoDirectory(path10) {
-          return toPath(path10, buildInfoDirectory, getCanonicalFileName);
+        function toPathInBuildInfoDirectory(path11) {
+          return toPath(path11, buildInfoDirectory, getCanonicalFileName);
         }
-        function toAbsolutePath(path10) {
-          return getNormalizedAbsolutePath(path10, buildInfoDirectory);
+        function toAbsolutePath(path11) {
+          return getNormalizedAbsolutePath(path11, buildInfoDirectory);
         }
         function toFilePath(fileId) {
           return filePaths[fileId - 1];
@@ -144815,30 +144815,30 @@ ${lanes.join("\n")}
         const roots = /* @__PURE__ */ new Map();
         const resolvedRoots = new Map(program2.resolvedRoot);
         program2.fileInfos.forEach((fileInfo, index) => {
-          const path10 = toPath(program2.fileNames[index], buildInfoDirectory, getCanonicalFileName);
+          const path11 = toPath(program2.fileNames[index], buildInfoDirectory, getCanonicalFileName);
           const version2 = isString(fileInfo) ? fileInfo : fileInfo.version;
-          fileInfos.set(path10, version2);
+          fileInfos.set(path11, version2);
           if (rootIndex < program2.root.length) {
             const current = program2.root[rootIndex];
             const fileId = index + 1;
             if (isArray(current)) {
               if (current[0] <= fileId && fileId <= current[1]) {
-                addRoot(fileId, path10);
+                addRoot(fileId, path11);
                 if (current[1] === fileId) rootIndex++;
               }
             } else if (current === fileId) {
-              addRoot(fileId, path10);
+              addRoot(fileId, path11);
               rootIndex++;
             }
           }
         });
         return { fileInfos, roots };
-        function addRoot(fileId, path10) {
+        function addRoot(fileId, path11) {
           const root = resolvedRoots.get(fileId);
           if (root) {
-            roots.set(toPath(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path10);
+            roots.set(toPath(program2.fileNames[root - 1], buildInfoDirectory, getCanonicalFileName), path11);
           } else {
-            roots.set(path10, void 0);
+            roots.set(path11, void 0);
           }
         }
       }
@@ -144913,11 +144913,11 @@ ${lanes.join("\n")}
           newConfigFileParsingDiagnostics
         );
       }
-      function removeIgnoredPath(path10) {
-        if (endsWith(path10, "/node_modules/.staging")) {
-          return removeSuffix(path10, "/.staging");
+      function removeIgnoredPath(path11) {
+        if (endsWith(path11, "/node_modules/.staging")) {
+          return removeSuffix(path11, "/.staging");
         }
-        return some(ignoredPaths, (searchPath) => path10.includes(searchPath)) ? void 0 : path10;
+        return some(ignoredPaths, (searchPath) => path11.includes(searchPath)) ? void 0 : path11;
       }
       function perceivedOsRootLengthForWatching(pathComponents2, length2) {
         if (length2 <= 1) return 1;
@@ -144943,8 +144943,8 @@ ${lanes.join("\n")}
         const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2);
         return length2 > perceivedOsRootLength + 1;
       }
-      function canWatchDirectoryOrFilePath(path10) {
-        return canWatchDirectoryOrFile(getPathComponents(path10));
+      function canWatchDirectoryOrFilePath(path11) {
+        return canWatchDirectoryOrFile(getPathComponents(path11));
       }
       function canWatchAtTypes(atTypes) {
         return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
@@ -145238,11 +145238,11 @@ ${lanes.join("\n")}
           filesWithChangedSetOfUnresolvedImports = void 0;
           return collected;
         }
-        function isFileWithInvalidatedNonRelativeUnresolvedImports(path10) {
+        function isFileWithInvalidatedNonRelativeUnresolvedImports(path11) {
           if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
             return false;
           }
-          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path10);
+          const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path11);
           return !!value && !!value.length;
         }
         function createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidatedLibResolutions) {
@@ -145250,7 +145250,7 @@ ${lanes.join("\n")}
           const collected = filesWithInvalidatedResolutions;
           filesWithInvalidatedResolutions = void 0;
           return {
-            hasInvalidatedResolutions: (path10) => customHasInvalidatedResolutions(path10) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path10)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path10),
+            hasInvalidatedResolutions: (path11) => customHasInvalidatedResolutions(path11) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path11)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path11),
             hasInvalidatedLibResolutions: (libFileName) => {
               var _a;
               return customHasInvalidatedLibResolutions(libFileName) || !!((_a = resolvedLibraries == null ? void 0 : resolvedLibraries.get(libFileName)) == null ? void 0 : _a.isInvalidated);
@@ -145306,11 +145306,11 @@ ${lanes.join("\n")}
               if (expected) impliedFormatPackageJsons.set(newFile.resolvedPath, newFile.packageJsonLocations);
               else impliedFormatPackageJsons.delete(newFile.resolvedPath);
             });
-            impliedFormatPackageJsons.forEach((existing, path10) => {
-              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path10);
-              if (!newFile || newFile.resolvedPath !== path10) {
+            impliedFormatPackageJsons.forEach((existing, path11) => {
+              const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path11);
+              if (!newFile || newFile.resolvedPath !== path11) {
                 existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
-                impliedFormatPackageJsons.delete(path10);
+                impliedFormatPackageJsons.delete(path11);
               }
             });
           }
@@ -145329,16 +145329,16 @@ ${lanes.join("\n")}
             packageDirWatchers.delete(packageDirPath);
           }
         }
-        function closeDirectoryWatchesOfFailedLookup(watcher, path10) {
+        function closeDirectoryWatchesOfFailedLookup(watcher, path11) {
           if (watcher.refCount === 0) {
-            directoryWatchesOfFailedLookups.delete(path10);
+            directoryWatchesOfFailedLookups.delete(path11);
             watcher.watcher.close();
           }
         }
-        function closeFileWatcherOfAffectingLocation(watcher, path10) {
+        function closeFileWatcherOfAffectingLocation(watcher, path11) {
           var _a;
           if (watcher.files === 0 && watcher.resolutions === 0 && !((_a = watcher.symlinks) == null ? void 0 : _a.size)) {
-            fileWatchesOfAffectingLocations.delete(path10);
+            fileWatchesOfAffectingLocations.delete(path11);
             watcher.watcher.close();
           }
         }
@@ -145357,10 +145357,10 @@ ${lanes.join("\n")}
           logChanges
         }) {
           var _a;
-          const path10 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = perFileCache.get(path10) || perFileCache.set(path10, createModeAwareCache()).get(path10);
+          const path11 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = perFileCache.get(path11) || perFileCache.set(path11, createModeAwareCache()).get(path11);
           const resolvedModules = [];
-          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path10);
+          const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path11);
           const program2 = resolutionHost.getCurrentProgram();
           const oldRedirect = program2 && ((_a = program2.getRedirectFromSourceFile(containingFile)) == null ? void 0 : _a.resolvedRef);
           const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
@@ -145378,13 +145378,13 @@ ${lanes.join("\n")}
               }
               resolutionsInFile.set(name, mode, resolution);
               if (resolution !== existingResolution) {
-                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path10, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+                watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path11, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
                 if (existingResolution) {
-                  stopWatchFailedLookupLocationOfResolution(existingResolution, path10, getResolutionWithResolvedFileName);
+                  stopWatchFailedLookupLocationOfResolution(existingResolution, path11, getResolutionWithResolvedFileName);
                 }
               }
               if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
-                filesWithChangedSetOfUnresolvedImports.push(path10);
+                filesWithChangedSetOfUnresolvedImports.push(path11);
                 logChanges = false;
               }
             } else {
@@ -145415,7 +145415,7 @@ ${lanes.join("\n")}
           if (resolutionsInFile.size() !== seenNamesInFile.size()) {
             resolutionsInFile.forEach((resolution, name, mode) => {
               if (!seenNamesInFile.has(name, mode)) {
-                stopWatchFailedLookupLocationOfResolution(resolution, path10, getResolutionWithResolvedFileName);
+                stopWatchFailedLookupLocationOfResolution(resolution, path11, getResolutionWithResolvedFileName);
                 resolutionsInFile.delete(name, mode);
               }
             });
@@ -145489,18 +145489,18 @@ ${lanes.join("\n")}
           if (!resolution || resolution.isInvalidated) {
             const existingResolution = resolution;
             resolution = resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
-            const path10 = resolutionHost.toPath(resolveFrom);
+            const path11 = resolutionHost.toPath(resolveFrom);
             watchFailedLookupLocationsOfExternalModuleResolutions(
               libraryName,
               resolution,
-              path10,
+              path11,
               getResolvedModuleFromResolution,
               /*deferWatchingNonRelativeResolution*/
               false
             );
             resolvedLibraries.set(libFileName, resolution);
             if (existingResolution) {
-              stopWatchFailedLookupLocationOfResolution(existingResolution, path10, getResolvedModuleFromResolution);
+              stopWatchFailedLookupLocationOfResolution(existingResolution, path11, getResolvedModuleFromResolution);
             }
           } else {
             if (isTraceEnabled(options, host)) {
@@ -145519,8 +145519,8 @@ ${lanes.join("\n")}
         }
         function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
           var _a, _b;
-          const path10 = resolutionHost.toPath(containingFile);
-          const resolutionsInFile = resolvedModuleNames.get(path10);
+          const path11 = resolutionHost.toPath(containingFile);
+          const resolutionsInFile = resolvedModuleNames.get(path11);
           const resolution = resolutionsInFile == null ? void 0 : resolutionsInFile.get(
             moduleName,
             /*mode*/
@@ -145677,13 +145677,13 @@ ${lanes.join("\n")}
             (symlinkWatcher.symlinks ?? (symlinkWatcher.symlinks = /* @__PURE__ */ new Set())).add(affectingLocation);
           }
         }
-        function invalidateAffectingFileWatcher(path10, packageJsonMap) {
+        function invalidateAffectingFileWatcher(path11, packageJsonMap) {
           var _a;
-          const watcher = fileWatchesOfAffectingLocations.get(path10);
-          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path10);
-          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path10);
+          const watcher = fileWatchesOfAffectingLocations.get(path11);
+          if (watcher == null ? void 0 : watcher.resolutions) (affectingPathChecks ?? (affectingPathChecks = /* @__PURE__ */ new Set())).add(path11);
+          if (watcher == null ? void 0 : watcher.files) (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path11);
           (_a = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a.forEach((path22) => invalidateAffectingFileWatcher(path22, packageJsonMap));
-          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path10));
+          packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path11));
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
           nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfResolution);
@@ -145922,7 +145922,7 @@ ${lanes.join("\n")}
         function invalidatePackageJsonMap() {
           const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
           if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
-            packageJsonMap.forEach((_value, path10) => isInvalidatedFailedLookup(path10) ? packageJsonMap.delete(path10) : void 0);
+            packageJsonMap.forEach((_value, path11) => isInvalidatedFailedLookup(path11) ? packageJsonMap.delete(path11) : void 0);
           }
         }
         function invalidateResolutionsOfFailedLookupLocations() {
@@ -146540,9 +146540,9 @@ ${lanes.join("\n")}
           getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
           getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
           writeFile: createWriteFileMeasuringIO(
-            (path10, data, writeByteOrderMark) => host.writeFile(path10, data, writeByteOrderMark),
-            (path10) => host.createDirectory(path10),
-            (path10) => host.directoryExists(path10)
+            (path11, data, writeByteOrderMark) => host.writeFile(path11, data, writeByteOrderMark),
+            (path11) => host.createDirectory(path11),
+            (path11) => host.directoryExists(path11)
           ),
           getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
           useCaseSensitiveFileNames: () => useCaseSensitiveFileNames2,
@@ -146613,16 +146613,16 @@ ${lanes.join("\n")}
           getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
           getDefaultLibLocation,
           getDefaultLibFileName: (options) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
-          fileExists: (path10) => system.fileExists(path10),
-          readFile: (path10, encoding) => system.readFile(path10, encoding),
-          directoryExists: (path10) => system.directoryExists(path10),
-          getDirectories: (path10) => system.getDirectories(path10),
-          readDirectory: (path10, extensions, exclude, include, depth) => system.readDirectory(path10, extensions, exclude, include, depth),
+          fileExists: (path11) => system.fileExists(path11),
+          readFile: (path11, encoding) => system.readFile(path11, encoding),
+          directoryExists: (path11) => system.directoryExists(path11),
+          getDirectories: (path11) => system.getDirectories(path11),
+          readDirectory: (path11, extensions, exclude, include, depth) => system.readDirectory(path11, extensions, exclude, include, depth),
           realpath: maybeBind(system, system.realpath),
           getEnvironmentVariable: maybeBind(system, system.getEnvironmentVariable),
           trace: (s) => system.write(s + system.newLine),
-          createDirectory: (path10) => system.createDirectory(path10),
-          writeFile: (path10, data, writeByteOrderMark) => system.writeFile(path10, data, writeByteOrderMark),
+          createDirectory: (path11) => system.createDirectory(path11),
+          writeFile: (path11, data, writeByteOrderMark) => system.writeFile(path11, data, writeByteOrderMark),
           createHash: maybeBind(system, system.createHash),
           createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
           storeSignatureInfo: system.storeSignatureInfo,
@@ -146935,7 +146935,7 @@ ${lanes.join("\n")}
             originalWriteFile,
             readFileWithCache
           } = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
-          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path10) => getSourceVersion(path10, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+          if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path11) => getSourceVersion(path11, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
             if (hasChangedConfigFileParsingErrors) {
               if (reportFileChangeDetectedOnCreateProgram) {
                 reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -147029,14 +147029,14 @@ ${lanes.join("\n")}
           return typeof hostSourceFile.version === "boolean";
         }
         function fileExists(fileName) {
-          const path10 = toPath3(fileName);
-          if (isFileMissingOnHost(sourceFilesCache.get(path10))) {
+          const path11 = toPath3(fileName);
+          if (isFileMissingOnHost(sourceFilesCache.get(path11))) {
             return false;
           }
           return directoryStructureHost.fileExists(fileName);
         }
-        function getVersionedSourceFileByPath(fileName, path10, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
-          const hostSourceFile = sourceFilesCache.get(path10);
+        function getVersionedSourceFileByPath(fileName, path11, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+          const hostSourceFile = sourceFilesCache.get(path11);
           if (isFileMissingOnHost(hostSourceFile)) {
             return void 0;
           }
@@ -147048,41 +147048,41 @@ ${lanes.join("\n")}
                 hostSourceFile.sourceFile = sourceFile;
                 hostSourceFile.version = sourceFile.version;
                 if (!hostSourceFile.fileWatcher) {
-                  hostSourceFile.fileWatcher = watchFilePath(path10, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                  hostSourceFile.fileWatcher = watchFilePath(path11, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
                 }
               } else {
                 if (hostSourceFile.fileWatcher) {
                   hostSourceFile.fileWatcher.close();
                 }
-                sourceFilesCache.set(path10, false);
+                sourceFilesCache.set(path11, false);
               }
             } else {
               if (sourceFile) {
-                const fileWatcher = watchFilePath(path10, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
-                sourceFilesCache.set(path10, { sourceFile, version: sourceFile.version, fileWatcher });
+                const fileWatcher = watchFilePath(path11, fileName, onSourceFileChange, 250, watchOptions, WatchType.SourceFile);
+                sourceFilesCache.set(path11, { sourceFile, version: sourceFile.version, fileWatcher });
               } else {
-                sourceFilesCache.set(path10, false);
+                sourceFilesCache.set(path11, false);
               }
             }
             return sourceFile;
           }
           return hostSourceFile.sourceFile;
         }
-        function nextSourceFileVersion(path10) {
-          const hostSourceFile = sourceFilesCache.get(path10);
+        function nextSourceFileVersion(path11) {
+          const hostSourceFile = sourceFilesCache.get(path11);
           if (hostSourceFile !== void 0) {
             if (isFileMissingOnHost(hostSourceFile)) {
-              sourceFilesCache.set(path10, { version: false });
+              sourceFilesCache.set(path11, { version: false });
             } else {
               hostSourceFile.version = false;
             }
           }
         }
-        function getSourceVersion(path10, readFileWithCache) {
-          const hostSourceFile = sourceFilesCache.get(path10);
+        function getSourceVersion(path11, readFileWithCache) {
+          const hostSourceFile = sourceFilesCache.get(path11);
           if (!hostSourceFile) return void 0;
           if (hostSourceFile.version) return hostSourceFile.version;
-          const text = readFileWithCache(path10);
+          const text = readFileWithCache(path11);
           return text !== void 0 ? getSourceFileVersionAsHashFromText(compilerHost, text) : void 0;
         }
         function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
@@ -147261,28 +147261,28 @@ ${lanes.join("\n")}
         }
         function onReleaseParsedCommandLine(fileName) {
           var _a;
-          const path10 = toPath3(fileName);
-          const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path10);
+          const path11 = toPath3(fileName);
+          const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path11);
           if (!config) return;
-          parsedConfigs.delete(path10);
+          parsedConfigs.delete(path11);
           if (config.watchedDirectories) clearMap(config.watchedDirectories, closeFileWatcherOf);
           (_a = config.watcher) == null ? void 0 : _a.close();
-          clearSharedExtendedConfigFileWatcher(path10, sharedExtendedConfigFileWatchers);
+          clearSharedExtendedConfigFileWatcher(path11, sharedExtendedConfigFileWatchers);
         }
-        function watchFilePath(path10, file, callback, pollingInterval, options, watchType) {
-          return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path10), pollingInterval, options, watchType);
+        function watchFilePath(path11, file, callback, pollingInterval, options, watchType) {
+          return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path11), pollingInterval, options, watchType);
         }
-        function onSourceFileChange(fileName, eventKind, path10) {
-          updateCachedSystemWithFile(fileName, path10, eventKind);
-          if (eventKind === 2 && sourceFilesCache.has(path10)) {
-            resolutionCache.invalidateResolutionOfFile(path10);
+        function onSourceFileChange(fileName, eventKind, path11) {
+          updateCachedSystemWithFile(fileName, path11, eventKind);
+          if (eventKind === 2 && sourceFilesCache.has(path11)) {
+            resolutionCache.invalidateResolutionOfFile(path11);
           }
-          nextSourceFileVersion(path10);
+          nextSourceFileVersion(path11);
           scheduleProgramUpdate();
         }
-        function updateCachedSystemWithFile(fileName, path10, eventKind) {
+        function updateCachedSystemWithFile(fileName, path11, eventKind) {
           if (cachedDirectoryStructureHost) {
-            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path10, eventKind);
+            cachedDirectoryStructureHost.addOrDeleteFile(fileName, path11, eventKind);
           }
         }
         function watchMissingFilePath(missingFilePath, missingFileName) {
@@ -147503,9 +147503,9 @@ ${lanes.join("\n")}
       }
       function createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus) {
         const host = createProgramHost(system, createProgram2);
-        host.getModifiedTime = system.getModifiedTime ? (path10) => system.getModifiedTime(path10) : returnUndefined;
-        host.setModifiedTime = system.setModifiedTime ? (path10, date) => system.setModifiedTime(path10, date) : noop;
-        host.deleteFile = system.deleteFile ? (path10) => system.deleteFile(path10) : noop;
+        host.getModifiedTime = system.getModifiedTime ? (path11) => system.getModifiedTime(path11) : returnUndefined;
+        host.setModifiedTime = system.setModifiedTime ? (path11, date) => system.setModifiedTime(path11, date) : noop;
+        host.deleteFile = system.deleteFile ? (path11) => system.deleteFile(path11) : noop;
         host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
         host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);
         host.now = maybeBind(system, system.now);
@@ -147676,8 +147676,8 @@ ${lanes.join("\n")}
       }
       function toResolvedConfigFilePath(state, fileName) {
         const { resolvedConfigFilePaths } = state;
-        const path10 = resolvedConfigFilePaths.get(fileName);
-        if (path10 !== void 0) return path10;
+        const path11 = resolvedConfigFilePaths.get(fileName);
+        if (path11 !== void 0) return path11;
         const resolvedPath = toPath2(state, fileName);
         resolvedConfigFilePaths.set(fileName, resolvedPath);
         return resolvedPath;
@@ -148065,7 +148065,7 @@ ${lanes.join("\n")}
             void 0,
             (name, text, writeByteOrderMark, onError, sourceFiles, data) => {
               var _a2;
-              const path10 = toPath2(state, name);
+              const path11 = toPath2(state, name);
               emittedOutputs.set(toPath2(state, name), name);
               if (data == null ? void 0 : data.buildInfo) {
                 now || (now = getCurrentTime(state.host));
@@ -148095,7 +148095,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(path10, now || (now = getCurrentTime(state.host)));
+                (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path11, now || (now = getCurrentTime(state.host)));
               }
             },
             cancellationToken,
@@ -148279,8 +148279,8 @@ ${lanes.join("\n")}
         return !!value.watcher;
       }
       function getModifiedTime2(state, fileName) {
-        const path10 = toPath2(state, fileName);
-        const existing = state.filesWatched.get(path10);
+        const path11 = toPath2(state, fileName);
+        const existing = state.filesWatched.get(path11);
         if (state.watch && !!existing) {
           if (!isFileWatcherWithModifiedTime(existing)) return existing;
           if (existing.modifiedTime) return existing.modifiedTime;
@@ -148288,20 +148288,20 @@ ${lanes.join("\n")}
         const result = getModifiedTime(state.host, fileName);
         if (state.watch) {
           if (existing) existing.modifiedTime = result;
-          else state.filesWatched.set(path10, result);
+          else state.filesWatched.set(path11, result);
         }
         return result;
       }
       function watchFile(state, file, callback, pollingInterval, options, watchType, project) {
-        const path10 = toPath2(state, file);
-        const existing = state.filesWatched.get(path10);
+        const path11 = toPath2(state, file);
+        const existing = state.filesWatched.get(path11);
         if (existing && isFileWatcherWithModifiedTime(existing)) {
           existing.callbacks.push(callback);
         } else {
           const watcher = state.watchFile(
             file,
             (fileName, eventKind, modifiedTime) => {
-              const existing2 = Debug.checkDefined(state.filesWatched.get(path10));
+              const existing2 = Debug.checkDefined(state.filesWatched.get(path11));
               Debug.assert(isFileWatcherWithModifiedTime(existing2));
               existing2.modifiedTime = modifiedTime;
               existing2.callbacks.forEach((cb) => cb(fileName, eventKind, modifiedTime));
@@ -148311,14 +148311,14 @@ ${lanes.join("\n")}
             watchType,
             project
           );
-          state.filesWatched.set(path10, { callbacks: [callback], watcher, modifiedTime: existing });
+          state.filesWatched.set(path11, { callbacks: [callback], watcher, modifiedTime: existing });
         }
         return {
           close: () => {
-            const existing2 = Debug.checkDefined(state.filesWatched.get(path10));
+            const existing2 = Debug.checkDefined(state.filesWatched.get(path11));
             Debug.assert(isFileWatcherWithModifiedTime(existing2));
             if (existing2.callbacks.length === 1) {
-              state.filesWatched.delete(path10);
+              state.filesWatched.delete(path11);
               closeFileWatcherOf(existing2);
             } else {
               unorderedRemoveItem(existing2.callbacks, callback);
@@ -148333,19 +148333,19 @@ ${lanes.join("\n")}
         return result;
       }
       function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
-        const path10 = toPath2(state, buildInfoPath);
+        const path11 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        return (existing == null ? void 0 : existing.path) === path10 ? existing : void 0;
+        return (existing == null ? void 0 : existing.path) === path11 ? existing : void 0;
       }
       function getBuildInfo3(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
-        const path10 = toPath2(state, buildInfoPath);
+        const path11 = toPath2(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
-        if (existing !== void 0 && existing.path === path10) {
+        if (existing !== void 0 && existing.path === path11) {
           return existing.buildInfo || void 0;
         }
         const value = state.readFileWithCache(buildInfoPath);
         const buildInfo = value ? getBuildInfo(buildInfoPath, value) : void 0;
-        state.buildInfoCache.set(resolvedConfigPath, { path: path10, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
+        state.buildInfoCache.set(resolvedConfigPath, { path: path11, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
         return buildInfo;
       }
       function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
@@ -148526,11 +148526,11 @@ ${lanes.join("\n")}
           const outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
           for (const output of outputs) {
             if (output === buildInfoPath) continue;
-            const path10 = toPath2(state, output);
-            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path10);
+            const path11 = toPath2(state, output);
+            let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path11);
             if (!outputTime) {
               outputTime = getModifiedTime(state.host, output);
-              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path10, outputTime);
+              outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path11, outputTime);
             }
             if (outputTime === missingFileModifiedTime) {
               return {
@@ -148584,7 +148584,7 @@ ${lanes.join("\n")}
         const packageJsonLookups = state.lastCachedPackageJsonLookups.get(resolvedPath);
         const dependentPackageFileStatus = packageJsonLookups && forEachKey(
           packageJsonLookups,
-          (path10) => checkConfigFileUpToDateStatus(state, path10, oldestOutputFileTime, oldestOutputFileName)
+          (path11) => checkConfigFileUpToDateStatus(state, path11, oldestOutputFileTime, oldestOutputFileName)
         );
         if (dependentPackageFileStatus) return dependentPackageFileStatus;
         return {
@@ -148634,8 +148634,8 @@ ${lanes.join("\n")}
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
           let reportVerbose = !!state.options.verbose;
           for (const file of outputs) {
-            const path10 = toPath2(state, file);
-            if (skipOutputs == null ? void 0 : skipOutputs.has(path10)) continue;
+            const path11 = toPath2(state, file);
+            if (skipOutputs == null ? void 0 : skipOutputs.has(path11)) continue;
             if (reportVerbose) {
               reportVerbose = false;
               reportStatus(state, verboseMessage, proj.options.configFilePath);
@@ -148643,8 +148643,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(path10, now);
-              modifiedOutputs.add(path10);
+              outputTimeStampMap.set(path11, now);
+              modifiedOutputs.add(path11);
             }
           }
         }
@@ -149072,8 +149072,8 @@ ${lanes.join("\n")}
           close: () => stopWatching(state)
         };
       }
-      function relName(state, path10) {
-        return convertToRelativePath(path10, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
+      function relName(state, path11) {
+        return convertToRelativePath(path11, state.compilerHost.getCurrentDirectory(), state.compilerHost.getCanonicalFileName);
       }
       function reportStatus(state, message, ...args) {
         state.host.reportSolutionBuilderStatus(createCompilerDiagnostic(message, ...args));
@@ -149292,13 +149292,13 @@ ${lanes.join("\n")}
         } else if (file.isDeclarationFile) {
           return "Definitions";
         }
-        const path10 = file.path;
-        if (fileExtensionIsOneOf(path10, supportedTSExtensionsFlat)) {
+        const path11 = file.path;
+        if (fileExtensionIsOneOf(path11, supportedTSExtensionsFlat)) {
           return "TypeScript";
-        } else if (fileExtensionIsOneOf(path10, supportedJSExtensionsFlat)) {
+        } else if (fileExtensionIsOneOf(path11, supportedJSExtensionsFlat)) {
           return "JavaScript";
         } else if (fileExtensionIs(
-          path10,
+          path11,
           ".json"
           /* Json */
         )) {
@@ -149910,7 +149910,7 @@ ${lanes.join("\n")}
             );
           }
         }
-        const commandLine = parseCommandLine(commandLineArgs, (path10) => system.readFile(path10));
+        const commandLine = parseCommandLine(commandLineArgs, (path11) => system.readFile(path11));
         if (commandLine.options.generateCpuProfile && system.enableCPUProfiler) {
           system.enableCPUProfiler(commandLine.options.generateCpuProfile, () => executeCommandLineWorker(
             system,
@@ -151786,12 +151786,12 @@ ${lanes.join("\n")}
         return nodeCoreModules.has(moduleName) ? "node" : moduleName;
       }
       function loadSafeList(host, safeListPath) {
-        const result = readConfigFile(safeListPath, (path10) => host.readFile(path10));
+        const result = readConfigFile(safeListPath, (path11) => host.readFile(path11));
         return new Map(Object.entries(result.config));
       }
       function loadTypesMap(host, typesMapPath) {
         var _a;
-        const result = readConfigFile(typesMapPath, (path10) => host.readFile(path10));
+        const result = readConfigFile(typesMapPath, (path11) => host.readFile(path11));
         if ((_a = result.config) == null ? void 0 : _a.simpleMap) {
           return new Map(Object.entries(result.config.simpleMap));
         }
@@ -151803,9 +151803,9 @@ ${lanes.join("\n")}
         }
         const inferredTypings = /* @__PURE__ */ new Map();
         fileNames = mapDefined(fileNames, (fileName) => {
-          const path10 = normalizePath(fileName);
-          if (hasJSFileExtension(path10)) {
-            return path10;
+          const path11 = normalizePath(fileName);
+          if (hasJSFileExtension(path11)) {
+            return path11;
           }
         });
         const filesToWatch = [];
@@ -151867,7 +151867,7 @@ ${lanes.join("\n")}
           let manifestTypingNames;
           if (host.fileExists(manifestPath)) {
             filesToWatch2.push(manifestPath);
-            manifest = readConfigFile(manifestPath, (path10) => host.readFile(path10)).config;
+            manifest = readConfigFile(manifestPath, (path11) => host.readFile(path11)).config;
             manifestTypingNames = flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], getOwnKeys);
             addInferredTypings(manifestTypingNames, `Typing names in '${manifestPath}' dependencies`);
           }
@@ -151901,7 +151901,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, (path10) => host.readFile(path10));
+            const result2 = readConfigFile(normalizedFileName, (path11) => host.readFile(path11));
             const manifest2 = result2.config;
             if (!manifest2.name) {
               continue;
@@ -154681,14 +154681,14 @@ ${lanes.join("\n")}
       function tryGetDirectories(host, directoryName) {
         return tryIOAndConsumeErrors(host, host.getDirectories, directoryName) || [];
       }
-      function tryReadDirectory(host, path10, extensions, exclude, include) {
-        return tryIOAndConsumeErrors(host, host.readDirectory, path10, extensions, exclude, include) || emptyArray;
+      function tryReadDirectory(host, path11, extensions, exclude, include) {
+        return tryIOAndConsumeErrors(host, host.readDirectory, path11, extensions, exclude, include) || emptyArray;
       }
-      function tryFileExists(host, path10) {
-        return tryIOAndConsumeErrors(host, host.fileExists, path10);
+      function tryFileExists(host, path11) {
+        return tryIOAndConsumeErrors(host, host.fileExists, path11);
       }
-      function tryDirectoryExists(host, path10) {
-        return tryAndIgnoreErrors(() => directoryProbablyExists(path10, host)) || false;
+      function tryDirectoryExists(host, path11) {
+        return tryAndIgnoreErrors(() => directoryProbablyExists(path11, host)) || false;
       }
       function tryAndIgnoreErrors(cb) {
         try {
@@ -155530,13 +155530,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: path10 }) => {
+        return ({ fileName, path: path11 }) => {
           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(path10),
+              getDirectoryPath(path11),
               (dirPath) => {
                 const symlinks = realpathsWithSymlinks.get(ensureTrailingDirectorySeparator(dirPath));
                 if (symlinks) {
@@ -157192,14 +157192,14 @@ ${lanes.join("\n")}
           return settingsOrHost;
         }
         function acquireDocument(fileName, compilationSettings, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
-          const path10 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path11 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return acquireDocumentWithKey(fileName, path10, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
+          return acquireDocumentWithKey(fileName, path11, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
         }
-        function acquireDocumentWithKey(fileName, path10, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
+        function acquireDocumentWithKey(fileName, path11, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path10,
+            path11,
             compilationSettings,
             key,
             scriptSnapshot,
@@ -157211,14 +157211,14 @@ ${lanes.join("\n")}
           );
         }
         function updateDocument(fileName, compilationSettings, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
-          const path10 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path11 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-          return updateDocumentWithKey(fileName, path10, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
+          return updateDocumentWithKey(fileName, path11, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
         }
-        function updateDocumentWithKey(fileName, path10, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
+        function updateDocumentWithKey(fileName, path11, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
           return acquireOrUpdateDocument(
             fileName,
-            path10,
+            path11,
             getCompilationSettings(compilationSettings),
             key,
             scriptSnapshot,
@@ -157234,7 +157234,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, path10, compilationSettingsOrHost, key, scriptSnapshot, version2, acquiring, scriptKind, languageVersionOrOptions) {
+        function acquireOrUpdateDocument(fileName, path11, compilationSettingsOrHost, key, scriptSnapshot, version2, acquiring, scriptKind, languageVersionOrOptions) {
           var _a, _b, _c, _d;
           scriptKind = ensureScriptKind(fileName, scriptKind);
           const compilationSettings = getCompilationSettings(compilationSettingsOrHost);
@@ -157242,7 +157242,7 @@ ${lanes.join("\n")}
           const scriptTarget = scriptKind === 6 ? 100 : getEmitScriptTarget(compilationSettings);
           const sourceFileOptions = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : {
             languageVersion: scriptTarget,
-            impliedNodeFormat: host && getImpliedNodeFormatForFile(path10, (_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(path11, (_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
           };
@@ -157255,15 +157255,15 @@ ${lanes.join("\n")}
             if (buckets.size > oldBucketCount) {
               tracing.instant(tracing.Phase.Session, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode });
             }
-            const otherBucketKey = !isDeclarationFileName(path10) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path10) && bucketKey);
+            const otherBucketKey = !isDeclarationFileName(path11) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path11) && bucketKey);
             if (otherBucketKey) {
-              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path10, key1: otherBucketKey, key2: keyWithMode });
+              tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path: path11, key1: otherBucketKey, key2: keyWithMode });
             }
           }
-          const bucketEntry = bucket.get(path10);
+          const bucketEntry = bucket.get(path11);
           let entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
           if (!entry && externalCache) {
-            const sourceFile = externalCache.getDocument(keyWithMode, path10);
+            const sourceFile = externalCache.getDocument(keyWithMode, path11);
             if (sourceFile && sourceFile.scriptKind === scriptKind && sourceFile.text === getSnapshotText(scriptSnapshot)) {
               Debug.assert(acquiring);
               entry = {
@@ -157284,7 +157284,7 @@ ${lanes.join("\n")}
               scriptKind
             );
             if (externalCache) {
-              externalCache.setDocument(keyWithMode, path10, sourceFile);
+              externalCache.setDocument(keyWithMode, path11, sourceFile);
             }
             entry = {
               sourceFile,
@@ -157295,7 +157295,7 @@ ${lanes.join("\n")}
             if (entry.sourceFile.version !== version2) {
               entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version2, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
               if (externalCache) {
-                externalCache.setDocument(keyWithMode, path10, entry.sourceFile);
+                externalCache.setDocument(keyWithMode, path11, entry.sourceFile);
               }
             }
             if (acquiring) {
@@ -157306,35 +157306,35 @@ ${lanes.join("\n")}
           return entry.sourceFile;
           function setBucketEntry() {
             if (!bucketEntry) {
-              bucket.set(path10, entry);
+              bucket.set(path11, entry);
             } else if (isDocumentRegistryEntry(bucketEntry)) {
               const scriptKindMap = /* @__PURE__ */ new Map();
               scriptKindMap.set(bucketEntry.sourceFile.scriptKind, bucketEntry);
               scriptKindMap.set(scriptKind, entry);
-              bucket.set(path10, scriptKindMap);
+              bucket.set(path11, scriptKindMap);
             } else {
               bucketEntry.set(scriptKind, entry);
             }
           }
         }
         function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) {
-          const path10 = toPath(fileName, currentDirectory, getCanonicalFileName);
+          const path11 = toPath(fileName, currentDirectory, getCanonicalFileName);
           const key = getKeyForCompilationSettings(compilationSettings);
-          return releaseDocumentWithKey(path10, key, scriptKind, impliedNodeFormat);
+          return releaseDocumentWithKey(path11, key, scriptKind, impliedNodeFormat);
         }
-        function releaseDocumentWithKey(path10, key, scriptKind, impliedNodeFormat) {
+        function releaseDocumentWithKey(path11, key, scriptKind, impliedNodeFormat) {
           const bucket = Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat)));
-          const bucketEntry = bucket.get(path10);
+          const bucketEntry = bucket.get(path11);
           const entry = getDocumentRegistryEntry(bucketEntry, scriptKind);
           entry.languageServiceRefCount--;
           Debug.assert(entry.languageServiceRefCount >= 0);
           if (entry.languageServiceRefCount === 0) {
             if (isDocumentRegistryEntry(bucketEntry)) {
-              bucket.delete(path10);
+              bucket.delete(path11);
             } else {
               bucketEntry.delete(scriptKind);
               if (bucketEntry.size === 1) {
-                bucket.set(path10, firstDefinedIterator(bucketEntry.values(), identity));
+                bucket.set(path11, firstDefinedIterator(bucketEntry.values(), identity));
               }
             }
           }
@@ -157370,10 +157370,10 @@ ${lanes.join("\n")}
       }
       function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper) {
         const canonicalOldPath = getCanonicalFileName(oldFileOrDirPath);
-        return (path10) => {
-          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path10, pos: 0 });
-          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path10);
-          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path10, getCanonicalFileName) : updatedPath;
+        return (path11) => {
+          const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path11, pos: 0 });
+          const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path11);
+          return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path11, getCanonicalFileName) : updatedPath;
         };
         function getUpdatedPath(pathToUpdate) {
           if (getCanonicalFileName(pathToUpdate) === canonicalOldPath) return newFileOrDirPath;
@@ -157449,10 +157449,10 @@ ${lanes.join("\n")}
           }
           return false;
         }
-        function relativePath(path10) {
+        function relativePath(path11) {
           return getRelativePathFromDirectory(
             configDir,
-            path10,
+            path11,
             /*ignoreCase*/
             !useCaseSensitiveFileNames2
           );
@@ -158260,8 +158260,8 @@ ${lanes.join("\n")}
           return toPath(fileName, currentDirectory, getCanonicalFileName);
         }
         function getDocumentPositionMapper2(generatedFileName, sourceFileName) {
-          const path10 = toPath3(generatedFileName);
-          const value = documentPositionMappers.get(path10);
+          const path11 = toPath3(generatedFileName);
+          const value = documentPositionMappers.get(path11);
           if (value) return value;
           let mapper;
           if (host.getDocumentPositionMapper) {
@@ -158275,7 +158275,7 @@ ${lanes.join("\n")}
               (f) => !host.fileExists || host.fileExists(f) ? host.readFile(f) : void 0
             );
           }
-          documentPositionMappers.set(path10, mapper || identitySourceMapConsumer);
+          documentPositionMappers.set(path11, mapper || identitySourceMapConsumer);
           return mapper || identitySourceMapConsumer;
         }
         function tryGetSourcePosition(info) {
@@ -158303,21 +158303,21 @@ ${lanes.join("\n")}
         function getSourceFile(fileName) {
           const program2 = host.getProgram();
           if (!program2) return void 0;
-          const path10 = toPath3(fileName);
-          const file = program2.getSourceFileByPath(path10);
-          return file && file.resolvedPath === path10 ? file : void 0;
+          const path11 = toPath3(fileName);
+          const file = program2.getSourceFileByPath(path11);
+          return file && file.resolvedPath === path11 ? file : void 0;
         }
         function getOrCreateSourceFileLike(fileName) {
-          const path10 = toPath3(fileName);
-          const fileFromCache = sourceFileLike.get(path10);
+          const path11 = toPath3(fileName);
+          const fileFromCache = sourceFileLike.get(path11);
           if (fileFromCache !== void 0) return fileFromCache ? fileFromCache : void 0;
           if (!host.readFile || host.fileExists && !host.fileExists(fileName)) {
-            sourceFileLike.set(path10, false);
+            sourceFileLike.set(path11, false);
             return void 0;
           }
           const text = host.readFile(fileName);
           const file = text ? createSourceFileLike(text) : false;
-          sourceFileLike.set(path10, file);
+          sourceFileLike.set(path11, file);
           return file ? file : void 0;
         }
         function getSourceFileLike(fileName) {
@@ -166403,12 +166403,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             directoryExists: (directoryName) => {
               return directoryProbablyExists(directoryName, host);
             },
-            getDirectories: (path10) => {
-              return host.getDirectories ? host.getDirectories(path10) : [];
+            getDirectories: (path11) => {
+              return host.getDirectories ? host.getDirectories(path11) : [];
             },
-            readDirectory: (path10, extensions, exclude, include, depth) => {
+            readDirectory: (path11, extensions, exclude, include, depth) => {
               Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
-              return host.readDirectory(path10, extensions, exclude, include, depth);
+              return host.readDirectory(path11, extensions, exclude, include, depth);
             },
             onReleaseOldSourceFile,
             onReleaseParsedCommandLine,
@@ -166471,11 +166471,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           program2.getTypeChecker();
           return;
           function getParsedCommandLine(fileName) {
-            const path10 = toPath(fileName, currentDirectory, getCanonicalFileName);
-            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path10);
+            const path11 = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path11);
             if (existing !== void 0) return existing || void 0;
             const result = host.getParsedCommandLine ? host.getParsedCommandLine(fileName) : getParsedCommandLineOfConfigFileUsingSourceFile(fileName);
-            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path10, result || false);
+            (parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path11, result || false);
             return result;
           }
           function getParsedCommandLineOfConfigFileUsingSourceFile(configFileName) {
@@ -166517,7 +166517,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, path10, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
+          function getOrCreateSourceFileByPath(fileName, path11, 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) {
@@ -166526,17 +166526,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             const scriptKind = getScriptKind(fileName, host);
             const scriptVersion = host.getScriptVersion(fileName);
             if (!shouldCreateNewSourceFile) {
-              const oldSourceFile = program2 && program2.getSourceFileByPath(path10);
+              const oldSourceFile = program2 && program2.getSourceFileByPath(path11);
               if (oldSourceFile) {
                 if (scriptKind === oldSourceFile.scriptKind || releasedScriptKinds.has(oldSourceFile.resolvedPath)) {
-                  return documentRegistry.updateDocumentWithKey(fileName, path10, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+                  return documentRegistry.updateDocumentWithKey(fileName, path11, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
                 } else {
                   documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program2.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
                   releasedScriptKinds.add(oldSourceFile.resolvedPath);
                 }
               }
             }
-            return documentRegistry.acquireDocumentWithKey(fileName, path10, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
+            return documentRegistry.acquireDocumentWithKey(fileName, path11, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
           }
         }
         function getProgram() {
@@ -167142,7 +167142,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 = (path10) => toPath(path10, currentDirectory, getCanonicalFileName);
+          const getPath = (path11) => toPath(path11, 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`");
         }
@@ -167486,8 +167486,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(path10) {
-            return path10.includes("/node_modules/");
+          function isNodeModulesFile(path11) {
+            return path11.includes("/node_modules/");
           }
         }
         function getRenameInfo2(fileName, position, preferences) {
@@ -181121,11 +181121,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
         });
       }
-      function generateJSDocParamTagsForDestructuring(path10, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
+      function generateJSDocParamTagsForDestructuring(path11, pattern, initializer, dotDotDotToken, isJs, isSnippet, checker, options, preferences) {
         if (!isJs) {
           return [
             getJSDocParamAnnotation(
-              path10,
+              path11,
               initializer,
               dotDotDotToken,
               isJs,
@@ -181139,7 +181139,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             )
           ];
         }
-        return patternWorker(path10, pattern, initializer, dotDotDotToken, { tabstop: 1 });
+        return patternWorker(path11, pattern, initializer, dotDotDotToken, { tabstop: 1 });
         function patternWorker(path22, pattern2, initializer2, dotDotDotToken2, counter) {
           if (isObjectBindingPattern(pattern2) && !dotDotDotToken2) {
             const oldTabstop = counter.tabstop;
@@ -185762,21 +185762,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function getFragmentDirectory(fragment) {
         return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
       }
-      function getCompletionsForPathMapping(path10, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program2, host, moduleSpecifierResolutionHost) {
-        const parsedPath = tryParsePattern(path10);
+      function getCompletionsForPathMapping(path11, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program2, host, moduleSpecifierResolutionHost) {
+        const parsedPath = tryParsePattern(path11);
         if (!parsedPath) {
           return emptyArray;
         }
         if (typeof parsedPath === "string") {
           return justPathMappingName(
-            path10,
+            path11,
             "script"
             /* scriptElement */
           );
         }
         const remainingFragment = tryRemovePrefix(fragment, parsedPath.prefix);
         if (remainingFragment === void 0) {
-          const starIsFullPathComponent = endsWith(path10, "/*");
+          const starIsFullPathComponent = endsWith(path11, "/*");
           return starIsFullPathComponent ? justPathMappingName(
             parsedPath.prefix,
             "directory"
@@ -185862,9 +185862,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(path10, prefix) {
+        function trimPrefixAndSuffix(path11, prefix) {
           return firstDefined(matchingSuffixes, (suffix) => {
-            const inner = withoutStartAndEnd(normalizePath(path10), prefix, suffix);
+            const inner = withoutStartAndEnd(normalizePath(path11), prefix, suffix);
             return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner);
           });
         }
@@ -185872,8 +185872,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(path10) {
-        return path10[0] === directorySeparator ? path10.slice(1) : path10;
+      function removeLeadingDirectorySeparator(path11) {
+        return path11[0] === directorySeparator ? path11.slice(1) : path11;
       }
       function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
         const ambientModules = checker.getAmbientModules().map((sym) => stripQuotes(sym.name));
@@ -185988,10 +185988,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           /* ESNext */
         ) ? void 0 : createTextSpan(textStart + offset, length2);
       }
-      function isPathRelativeToScript(path10) {
-        if (path10 && path10.length >= 2 && path10.charCodeAt(0) === 46) {
-          const slashIndex = path10.length >= 3 && path10.charCodeAt(1) === 46 ? 2 : 1;
-          const slashCharCode = path10.charCodeAt(slashIndex);
+      function isPathRelativeToScript(path11) {
+        if (path11 && path11.length >= 2 && path11.charCodeAt(0) === 46) {
+          const slashIndex = path11.length >= 3 && path11.charCodeAt(1) === 46 ? 2 : 1;
+          const slashCharCode = path11.charCodeAt(slashIndex);
           return slashCharCode === 47 || slashCharCode === 92;
         }
         return false;
@@ -201962,17 +201962,17 @@ ${options.prefix}` : "\n" : options.prefix
       function createNormalizedPathMap() {
         const map2 = /* @__PURE__ */ new Map();
         return {
-          get(path10) {
-            return map2.get(path10);
+          get(path11) {
+            return map2.get(path11);
           },
-          set(path10, value) {
-            map2.set(path10, value);
+          set(path11, value) {
+            map2.set(path11, value);
           },
-          contains(path10) {
-            return map2.has(path10);
+          contains(path11) {
+            return map2.has(path11);
           },
-          remove(path10) {
-            map2.delete(path10);
+          remove(path11) {
+            map2.delete(path11);
           }
         };
       }
@@ -202485,12 +202485,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, path10, initialVersion) {
+        constructor(host, fileName, scriptKind, hasMixedContent, path11, initialVersion) {
           this.host = host;
           this.fileName = fileName;
           this.scriptKind = scriptKind;
           this.hasMixedContent = hasMixedContent;
-          this.path = path10;
+          this.path = path11;
           this.containingProjects = [];
           this.isDynamic = isDynamicFileName(fileName);
           this.textStorage = new TextStorage(host, this, initialVersion);
@@ -203125,8 +203125,8 @@ ${options.prefix}` : "\n" : options.prefix
         useCaseSensitiveFileNames() {
           return this.projectService.host.useCaseSensitiveFileNames;
         }
-        readDirectory(path10, extensions, exclude, include, depth) {
-          return this.directoryStructureHost.readDirectory(path10, extensions, exclude, include, depth);
+        readDirectory(path11, extensions, exclude, include, depth) {
+          return this.directoryStructureHost.readDirectory(path11, extensions, exclude, include, depth);
         }
         readFile(fileName) {
           return this.projectService.host.readFile(fileName);
@@ -203135,8 +203135,8 @@ ${options.prefix}` : "\n" : options.prefix
           return this.projectService.host.writeFile(fileName, content);
         }
         fileExists(file) {
-          const path10 = this.toPath(file);
-          return !!this.projectService.getScriptInfoForPath(path10) || !this.isWatchedMissingFile(path10) && this.directoryStructureHost.fileExists(file);
+          const path11 = this.toPath(file);
+          return !!this.projectService.getScriptInfoForPath(path11) || !this.isWatchedMissingFile(path11) && this.directoryStructureHost.fileExists(file);
         }
         /** @internal */
         resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
@@ -203161,11 +203161,11 @@ ${options.prefix}` : "\n" : options.prefix
         resolveLibrary(libraryName, resolveFrom, options, libFileName) {
           return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName);
         }
-        directoryExists(path10) {
-          return this.directoryStructureHost.directoryExists(path10);
+        directoryExists(path11) {
+          return this.directoryStructureHost.directoryExists(path11);
         }
-        getDirectories(path10) {
-          return this.directoryStructureHost.getDirectories(path10);
+        getDirectories(path11) {
+          return this.directoryStructureHost.getDirectories(path11);
         }
         /** @internal */
         getCachedDirectoryStructureHost() {
@@ -203428,16 +203428,16 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }));
         }
-        getSourceFile(path10) {
+        getSourceFile(path11) {
           if (!this.program) {
             return void 0;
           }
-          return this.program.getSourceFileByPath(path10);
+          return this.program.getSourceFileByPath(path11);
         }
         /** @internal */
-        getSourceFileOrConfigFile(path10) {
+        getSourceFileOrConfigFile(path11) {
           const options = this.program.getCompilerOptions();
-          return path10 === options.configFilePath ? options.configFile : this.getSourceFile(path10);
+          return path11 === options.configFilePath ? options.configFile : this.getSourceFile(path11);
         }
         close() {
           var _a;
@@ -203614,8 +203614,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         // add a root file that doesnt exist on host
         addMissingFileRoot(fileName) {
-          const path10 = this.projectService.toPath(fileName);
-          this.rootFilesMap.set(path10, { fileName });
+          const path11 = this.projectService.toPath(fileName);
+          this.rootFilesMap.set(path11, { fileName });
           this.markAsDirty();
         }
         removeFile(info, fileExists, detachFromProject) {
@@ -203781,22 +203781,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 = (path10, typingsWatcherType) => {
-            const canonicalPath = this.toPath(path10);
+          const createProjectWatcher = (path11, typingsWatcherType) => {
+            const canonicalPath = this.toPath(path11);
             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(
-                  path10,
+                  path11,
                   () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`),
                   2e3,
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
                 ) : this.projectService.watchFactory.watchDirectory(
-                  path10,
+                  path11,
                   (f) => {
                     if (this.typingWatchers.isInvoked) return this.writeLog(`TypingWatchers already invoked`);
                     if (!fileExtensionIs(
@@ -203811,7 +203811,7 @@ ${options.prefix}` : "\n" : options.prefix
                   this.projectService.getWatchOptions(this),
                   watchType,
                   this
-                ) : (this.writeLog(`Skipping watcher creation at ${path10}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
+                ) : (this.writeLog(`Skipping watcher creation at ${path11}:: ${getDetailWatchInfo(watchType, this)}`), noopFileWatcher)
               );
             }
           };
@@ -203856,9 +203856,9 @@ ${options.prefix}` : "\n" : options.prefix
               /* DirectoryWatcher */
             );
           }
-          toRemove.forEach((watch, path10) => {
+          toRemove.forEach((watch, path11) => {
             watch.close();
-            this.typingWatchers.delete(path10);
+            this.typingWatchers.delete(path11);
           });
         }
         /** @internal */
@@ -203892,9 +203892,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, path10) => {
+            this.rootFilesMap.forEach((value, path11) => {
               var _a2;
-              const file = this.program.getSourceFileByPath(path10);
+              const file = this.program.getSourceFileByPath(path11);
               const info = value.info;
               if (!file || ((_a2 = value.info) == null ? void 0 : _a2.path) === file.resolvedPath) return;
               value.info = this.projectService.getScriptInfo(file.fileName);
@@ -204050,8 +204050,8 @@ ${options.prefix}` : "\n" : options.prefix
           );
           return fileWatcher;
         }
-        isWatchedMissingFile(path10) {
-          return !!this.missingFilesMap && this.missingFilesMap.has(path10);
+        isWatchedMissingFile(path11) {
+          return !!this.missingFilesMap && this.missingFilesMap.has(path11);
         }
         /** @internal */
         addGeneratedFileWatch(generatedFile, sourceFile) {
@@ -204060,17 +204060,17 @@ ${options.prefix}` : "\n" : options.prefix
               this.generatedFilesMap = this.createGeneratedFileWatcher(generatedFile);
             }
           } else {
-            const path10 = this.toPath(sourceFile);
+            const path11 = 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(path10)) return;
+              if (this.generatedFilesMap.has(path11)) return;
             } else {
               this.generatedFilesMap = /* @__PURE__ */ new Map();
             }
-            this.generatedFilesMap.set(path10, this.createGeneratedFileWatcher(generatedFile));
+            this.generatedFilesMap.set(path11, this.createGeneratedFileWatcher(generatedFile));
           }
         }
         createGeneratedFileWatcher(generatedFile) {
@@ -204470,7 +204470,7 @@ ${options.prefix}` : "\n" : options.prefix
         isDefaultProjectForOpenFiles() {
           return !!forEachEntry(
             this.projectService.openFiles,
-            (_projectRootPath, path10) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path10)) === this
+            (_projectRootPath, path11) => this.projectService.tryGetDefaultProjectForFile(this.projectService.getScriptInfoForPath(path11)) === this
           );
         }
         /** @internal */
@@ -205644,33 +205644,33 @@ ${options.prefix}` : "\n" : options.prefix
           getCurrentDirectory: () => service.host.getCurrentDirectory(),
           useCaseSensitiveFileNames: service.host.useCaseSensitiveFileNames
         };
-        function watchFile2(path10, callback) {
+        function watchFile2(path11, callback) {
           return getOrCreateFileWatcher(
             watchedFiles,
-            path10,
+            path11,
             callback,
-            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path10 } })
+            (id) => ({ eventName: CreateFileWatcherEvent, data: { id, path: path11 } })
           );
         }
-        function watchDirectory(path10, callback, recursive) {
+        function watchDirectory(path11, callback, recursive) {
           return getOrCreateFileWatcher(
             recursive ? watchedDirectoriesRecursive : watchedDirectories,
-            path10,
+            path11,
             callback,
             (id) => ({
               eventName: CreateDirectoryWatcherEvent,
               data: {
                 id,
-                path: path10,
+                path: path11,
                 recursive: !!recursive,
                 // Special case node_modules as we watch it for changes to closed script infos as well
-                ignoreUpdate: !path10.endsWith("/node_modules") ? true : void 0
+                ignoreUpdate: !path11.endsWith("/node_modules") ? true : void 0
               }
             })
           );
         }
-        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path10, callback, event) {
-          const key = service.toPath(path10);
+        function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path11, callback, event) {
+          const key = service.toPath(path11);
           let id = pathToId.get(key);
           if (!id) pathToId.set(key, id = ids++);
           let callbacks = idToCallbacks.get(id);
@@ -205839,13 +205839,13 @@ ${options.prefix}` : "\n" : options.prefix
           return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
         }
         /** @internal */
-        setDocument(key, path10, sourceFile) {
-          const info = Debug.checkDefined(this.getScriptInfoForPath(path10));
+        setDocument(key, path11, sourceFile) {
+          const info = Debug.checkDefined(this.getScriptInfoForPath(path11));
           info.cacheSourceFile = { key, sourceFile };
         }
         /** @internal */
-        getDocument(key, path10) {
-          const info = this.getScriptInfoForPath(path10);
+        getDocument(key, path11) {
+          const info = this.getScriptInfoForPath(path11);
           return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : void 0;
         }
         /** @internal */
@@ -205967,7 +205967,7 @@ ${options.prefix}` : "\n" : options.prefix
           const event = {
             eventName: ProjectsUpdatedInBackgroundEvent,
             data: {
-              openFiles: arrayFrom(this.openFiles.keys(), (path10) => this.getScriptInfoForPath(path10).fileName)
+              openFiles: arrayFrom(this.openFiles.keys(), (path11) => this.getScriptInfoForPath(path11).fileName)
             }
           };
           this.eventHandler(event);
@@ -206189,11 +206189,11 @@ ${options.prefix}` : "\n" : options.prefix
         }
         delayUpdateSourceInfoProjects(sourceInfos) {
           if (sourceInfos) {
-            sourceInfos.forEach((_value, path10) => this.delayUpdateProjectsOfScriptInfoPath(path10));
+            sourceInfos.forEach((_value, path11) => this.delayUpdateProjectsOfScriptInfoPath(path11));
           }
         }
-        delayUpdateProjectsOfScriptInfoPath(path10) {
-          const info = this.getScriptInfoForPath(path10);
+        delayUpdateProjectsOfScriptInfoPath(path11) {
+          const info = this.getScriptInfoForPath(path11);
           if (info) {
             this.delayUpdateProjectGraphs(
               info.containingProjects,
@@ -206287,8 +206287,8 @@ ${options.prefix}` : "\n" : options.prefix
             const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
             if (!project) return;
             if (configuredProjectForConfig !== project && this.getHostPreferences().includeCompletionsForModuleExports) {
-              const path10 = this.toPath(configFileName);
-              if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path10)) {
+              const path11 = this.toPath(configFileName);
+              if (find((_a = project.getCurrentProgram()) == null ? void 0 : _a.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path11)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -206343,10 +206343,10 @@ ${options.prefix}` : "\n" : options.prefix
                 });
                 return;
               }
-              const path10 = this.toPath(canonicalConfigFilePath);
-              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path10);
+              const path11 = this.toPath(canonicalConfigFilePath);
+              project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(path11);
               this.delayUpdateProjectGraph(project);
-              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path10)) {
+              if (this.getHostPreferences().includeCompletionsForModuleExports && find((_c = project.getCurrentProgram()) == null ? void 0 : _c.getResolvedProjectReferences(), (ref) => (ref == null ? void 0 : ref.sourceFile.path) === path11)) {
                 project.markAutoImportProviderAsDirty();
               }
             }
@@ -206371,20 +206371,20 @@ ${options.prefix}` : "\n" : options.prefix
             canonicalConfigFilePath,
             "Change in config file detected"
           );
-          this.openFiles.forEach((_projectRootPath, path10) => {
+          this.openFiles.forEach((_projectRootPath, path11) => {
             var _a, _b;
-            const configFileForOpenFile = this.configFileForOpenFiles.get(path10);
-            if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path10))) return;
-            this.configFileForOpenFiles.delete(path10);
-            const info = this.getScriptInfoForPath(path10);
+            const configFileForOpenFile = this.configFileForOpenFiles.get(path11);
+            if (!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.has(path11))) return;
+            this.configFileForOpenFiles.delete(path11);
+            const info = this.getScriptInfoForPath(path11);
             const newConfigFileNameForInfo = this.getConfigFileNameForFile(
               info,
               /*findFromCacheOnly*/
               false
             );
             if (!newConfigFileNameForInfo) return;
-            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path10))) {
-              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path10, configFileForOpenFile);
+            if (!((_b = this.pendingOpenFileProjectUpdates) == null ? void 0 : _b.has(path11))) {
+              (this.pendingOpenFileProjectUpdates ?? (this.pendingOpenFileProjectUpdates = /* @__PURE__ */ new Map())).set(path11, configFileForOpenFile);
             }
           });
           this.delayEnsureProjectForOpenFiles();
@@ -206479,8 +206479,8 @@ ${options.prefix}` : "\n" : options.prefix
           return project;
         }
         assignOrphanScriptInfosToInferredProject() {
-          this.openFiles.forEach((projectRootPath, path10) => {
-            const info = this.getScriptInfoForPath(path10);
+          this.openFiles.forEach((projectRootPath, path11) => {
+            const info = this.getScriptInfoForPath(path11);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             }
@@ -206792,8 +206792,8 @@ ${options.prefix}` : "\n" : options.prefix
           this.configuredProjects.forEach(printProjectWithoutFileNames);
           this.inferredProjects.forEach(printProjectWithoutFileNames);
           this.logger.info("Open files: ");
-          this.openFiles.forEach((projectRootPath, path10) => {
-            const info = this.getScriptInfoForPath(path10);
+          this.openFiles.forEach((projectRootPath, path11) => {
+            const info = this.getScriptInfoForPath(path11);
             this.logger.info(`	FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
             this.logger.info(`		Projects: ${info.containingProjects.map((p) => p.getProjectName())}`);
           });
@@ -207119,12 +207119,12 @@ ${options.prefix}` : "\n" : options.prefix
             const newRootFile = propertyReader.getFileName(f);
             const fileName = toNormalizedPath(newRootFile);
             const isDynamic = isDynamicFileName(fileName);
-            let path10;
+            let path11;
             if (!isDynamic && !project.fileExists(newRootFile)) {
-              path10 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
-              const existingValue = projectRootFilesMap.get(path10);
+              path11 = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
+              const existingValue = projectRootFilesMap.get(path11);
               if (existingValue) {
-                if (((_a = existingValue.info) == null ? void 0 : _a.path) === path10) {
+                if (((_a = existingValue.info) == null ? void 0 : _a.path) === path11) {
                   project.removeFile(
                     existingValue.info,
                     /*fileExists*/
@@ -207136,7 +207136,7 @@ ${options.prefix}` : "\n" : options.prefix
                 }
                 existingValue.fileName = fileName;
               } else {
-                projectRootFilesMap.set(path10, { fileName });
+                projectRootFilesMap.set(path11, { fileName });
               }
             } else {
               const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions);
@@ -207150,8 +207150,8 @@ ${options.prefix}` : "\n" : options.prefix
                 /*deferredDeleteOk*/
                 false
               ));
-              path10 = scriptInfo.path;
-              const existingValue = projectRootFilesMap.get(path10);
+              path11 = scriptInfo.path;
+              const existingValue = projectRootFilesMap.get(path11);
               if (!existingValue || existingValue.info !== scriptInfo) {
                 project.addRoot(scriptInfo, fileName);
                 if (scriptInfo.isScriptOpen()) {
@@ -207161,11 +207161,11 @@ ${options.prefix}` : "\n" : options.prefix
                 existingValue.fileName = fileName;
               }
             }
-            newRootScriptInfoMap.set(path10, true);
+            newRootScriptInfoMap.set(path11, true);
           }
           if (projectRootFilesMap.size > newRootScriptInfoMap.size) {
-            projectRootFilesMap.forEach((value, path10) => {
-              if (!newRootScriptInfoMap.has(path10)) {
+            projectRootFilesMap.forEach((value, path11) => {
+              if (!newRootScriptInfoMap.has(path11)) {
                 if (value.info) {
                   project.removeFile(
                     value.info,
@@ -207174,7 +207174,7 @@ ${options.prefix}` : "\n" : options.prefix
                     true
                   );
                 } else {
-                  projectRootFilesMap.delete(path10);
+                  projectRootFilesMap.delete(path11);
                 }
               }
             });
@@ -207411,8 +207411,8 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @internal */
         getScriptInfoOrConfig(uncheckedFileName) {
-          const path10 = toNormalizedPath(uncheckedFileName);
-          const info = this.getScriptInfoForNormalizedPath(path10);
+          const path11 = toNormalizedPath(uncheckedFileName);
+          const info = this.getScriptInfoForNormalizedPath(path11);
           if (info) return info;
           const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName));
           return configProject && configProject.getCompilerOptions().configFile;
@@ -207424,7 +207424,7 @@ ${options.prefix}` : "\n" : options.prefix
               this.filenameToScriptInfo.entries(),
               (entry) => entry[1].deferredDelete ? void 0 : entry
             ),
-            ([path10, scriptInfo]) => ({ path: path10, fileName: scriptInfo.fileName })
+            ([path11, scriptInfo]) => ({ path: path11, fileName: scriptInfo.fileName })
           );
           this.logger.msg(
             `Could not find file ${JSON.stringify(fileName)}.
@@ -207456,7 +207456,7 @@ All files are: ${JSON.stringify(names)}`,
                   if (!projects) {
                     projects = createMultiMap();
                     projects.add(toAddInfo.path, project);
-                  } else if (!forEachEntry(projects, (projs, path10) => path10 === toAddInfo.path ? false : contains(projs, project))) {
+                  } else if (!forEachEntry(projects, (projs, path11) => path11 === toAddInfo.path ? false : contains(projs, project))) {
                     projects.add(toAddInfo.path, project);
                   }
                 }
@@ -207618,8 +207618,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 path10 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
-          let info = this.filenameToScriptInfo.get(path10);
+          const path11 = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
+          let info = this.filenameToScriptInfo.get(path11);
           if (!info) {
             const isDynamic = isDynamicFileName(fileName);
             Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
@@ -207631,7 +207631,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, path10, this.filenameToScriptInfoVersion.get(path10));
+            info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path11, this.filenameToScriptInfoVersion.get(path11));
             this.filenameToScriptInfo.set(info.path, info);
             this.filenameToScriptInfoVersion.delete(info.path);
             if (!openedByClient) {
@@ -207778,9 +207778,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 path10 = project.toPath(fileName);
-            const sourceFile = project.getSourceFile(path10);
-            if (sourceFile && sourceFile.resolvedPath === path10) return sourceFile;
+            const path11 = project.toPath(fileName);
+            const sourceFile = project.getSourceFile(path11);
+            if (sourceFile && sourceFile.resolvedPath === path11) return sourceFile;
           }
           const info = this.getOrCreateScriptInfoNotOpenedByClient(
             fileName,
@@ -207946,8 +207946,8 @@ Dynamic files must always be opened with service's current directory or service
               }
             });
           });
-          this.openFiles.forEach((_projectRootPath, path10) => {
-            const info = this.getScriptInfoForPath(path10);
+          this.openFiles.forEach((_projectRootPath, path11) => {
+            const info = this.getScriptInfoForPath(path11);
             if (find(info.containingProjects, isExternalProject)) return;
             this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -208000,14 +208000,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, path10) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
-              this.getScriptInfoForPath(path10),
+            (_config, path11) => this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
+              this.getScriptInfoForPath(path11),
               5
               /* Create */
             )
           );
-          this.openFiles.forEach((projectRootPath, path10) => {
-            const info = this.getScriptInfoForPath(path10);
+          this.openFiles.forEach((projectRootPath, path11) => {
+            const info = this.getScriptInfoForPath(path11);
             if (info.isOrphan()) {
               this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             } else {
@@ -208518,9 +208518,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           });
           if (!toRemoveConfiguredProjects.size) return toRemoveConfiguredProjects;
-          forEachEntry(this.openFiles, (_projectRootPath, path10) => {
-            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path10)) return;
-            const info = this.getScriptInfoForPath(path10);
+          forEachEntry(this.openFiles, (_projectRootPath, path11) => {
+            if (openFilesWithRetainedConfiguredProject == null ? void 0 : openFilesWithRetainedConfiguredProject.has(path11)) return;
+            const info = this.getScriptInfoForPath(path11);
             if (find(info.containingProjects, isExternalProject)) return;
             const result = this.tryFindDefaultConfiguredProjectAndLoadAncestorsForOpenScriptInfo(
               info,
@@ -208569,8 +208569,8 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (!sourceInfos) return;
-              if (!forEachKey(sourceInfos, (path10) => {
-                const info2 = this.getScriptInfoForPath(path10);
+              if (!forEachKey(sourceInfos, (path11) => {
+                const info2 = this.getScriptInfoForPath(path11);
                 return !!info2 && (info2.isScriptOpen() || !info2.isOrphan());
               })) {
                 return;
@@ -208594,7 +208594,7 @@ Dynamic files must always be opened with service's current directory or service
                 sourceInfos = info.sourceMapFilePath.sourceInfos;
               }
               if (sourceInfos) {
-                sourceInfos.forEach((_value, path10) => toRemoveScriptInfos.delete(path10));
+                sourceInfos.forEach((_value, path11) => toRemoveScriptInfos.delete(path11));
               }
             }
           });
@@ -209077,9 +209077,9 @@ Dynamic files must always be opened with service's current directory or service
             }
           );
         }
-        watchPackageJsonFile(file, path10, project) {
+        watchPackageJsonFile(file, path11, project) {
           Debug.assert(project !== void 0);
-          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path10);
+          let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path11);
           if (!result) {
             let watcher = this.watchFactory.watchFile(
               file,
@@ -209087,11 +209087,11 @@ Dynamic files must always be opened with service's current directory or service
                 switch (eventKind) {
                   case 0:
                   case 1:
-                    this.packageJsonCache.addOrUpdate(fileName, path10);
+                    this.packageJsonCache.addOrUpdate(fileName, path11);
                     this.onPackageJsonChange(result);
                     break;
                   case 2:
-                    this.packageJsonCache.delete(path10);
+                    this.packageJsonCache.delete(path11);
                     this.onPackageJsonChange(result);
                     result.projects.clear();
                     result.close();
@@ -209108,11 +209108,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(path10);
-                this.packageJsonCache.invalidate(path10);
+                (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path11);
+                this.packageJsonCache.invalidate(path11);
               }
             };
-            this.packageJsonFilesMap.set(path10, result);
+            this.packageJsonFilesMap.set(path11, result);
           }
           result.projects.add(project);
           (project.packageJsonWatches ?? (project.packageJsonWatches = /* @__PURE__ */ new Set())).add(result);
@@ -209302,14 +209302,14 @@ Dynamic files must always be opened with service's current directory or service
             );
           }
         };
-        function addOrUpdate(fileName, path10) {
+        function addOrUpdate(fileName, path11) {
           const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host));
-          packageJsons.set(path10, packageJsonInfo);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path10));
+          packageJsons.set(path11, packageJsonInfo);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path11));
         }
-        function invalidate(path10) {
-          packageJsons.delete(path10);
-          directoriesWithoutPackageJson.delete(getDirectoryPath(path10));
+        function invalidate(path11) {
+          packageJsons.delete(path11);
+          directoriesWithoutPackageJson.delete(getDirectoryPath(path11));
         }
         function directoryHasPackageJson(directory) {
           return packageJsons.has(combinePaths(directory, "package.json")) ? -1 : directoriesWithoutPackageJson.has(directory) ? 0 : 3;
@@ -209506,8 +209506,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, path10) => {
-            const value = getValue(path10);
+          projects.symLinkedProjects.forEach((projects2, path11) => {
+            const value = getValue(path11);
             outputs.push(...flatMap(projects2, (project) => action(project, value)));
           });
         }
@@ -209653,9 +209653,9 @@ ${json}${newLine}`;
         });
         return results.filter((o) => o.references.length !== 0);
       }
-      function forEachProjectInProjects(projects, path10, cb) {
+      function forEachProjectInProjects(projects, path11, cb) {
         for (const project of isArray(projects) ? projects : projects.projects) {
-          cb(project, path10);
+          cb(project, path11);
         }
         if (!isArray(projects) && projects.symLinkedProjects) {
           projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => {
@@ -209669,8 +209669,8 @@ ${json}${newLine}`;
         const resultsMap = /* @__PURE__ */ new Map();
         const queue = createQueue();
         queue.enqueue({ project: defaultProject, location: initialLocation });
-        forEachProjectInProjects(projects, initialLocation.fileName, (project, path10) => {
-          const location = { fileName: path10, pos: initialLocation.pos };
+        forEachProjectInProjects(projects, initialLocation.fileName, (project, path11) => {
+          const location = { fileName: path11, pos: initialLocation.pos };
           queue.enqueue({ project, location });
         });
         const projectService = defaultProject.projectService;
@@ -211512,8 +211512,8 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
                 nodeModulesPathParts.packageRootIndex
               );
               const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart));
-              const path10 = project.toPath(fileName);
-              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path10)) {
+              const path11 = project.toPath(fileName);
+              if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path11)) {
                 return (_b = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(packageName, resolveFromFile).resolvedModule) == null ? void 0 : _b.resolvedFileName;
               } else {
                 const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1);
@@ -212293,7 +212293,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           }
           return combineProjectOutput(
             info,
-            (path10) => this.projectService.getScriptInfoForPath(path10),
+            (path11) => this.projectService.getScriptInfoForPath(path11),
             projects,
             (project, info2) => {
               if (!project.compileOnSaveEnabled || !project.languageServiceEnabled || project.isOrphan()) {
@@ -212320,7 +212320,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, (path10, data, writeByteOrderMark) => this.host.writeFile(path10, data, writeByteOrderMark));
+          const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path11, data, writeByteOrderMark) => this.host.writeFile(path11, data, writeByteOrderMark));
           return args.richResponse ? {
             emitSkipped,
             diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) : diagnostics.map((d) => formatDiagnosticToProtocol(
@@ -215502,8 +215502,8 @@ async function generateWithHeuristics(descriptor, options) {
   };
 }
 async function extractExamplesFromTests(testFile, _ruleId) {
-  const fs12 = await import("fs/promises");
-  const content = await fs12.readFile(testFile, "utf-8");
+  const fs14 = await import("fs/promises");
+  const content = await fs14.readFile(testFile, "utf-8");
   const examples = [];
   const testPattern = /(?:it|test)\s*\(\s*(?:'((?:\\'|[^'])*)'|"((?:\\"|[^"])*)"|`((?:\\`|[^`])*?)`)/g;
   let match;
@@ -215701,14 +215701,14 @@ async function writeLedgerSnapshots(registry, options) {
   }
 }
 async function hasArtifactFile(type, ruleId) {
-  const fs12 = await import("fs/promises");
-  const path10 = await import("path");
+  const fs14 = await import("fs/promises");
+  const path11 = await import("path");
   const candidateDirs = type === "tests" ? ["src/__tests__", "tests", "test"] : ["spec", "specs"];
   const sanitized = ruleId.replace(/[^a-zA-Z0-9_-]/g, "_");
   for (const dir of candidateDirs) {
-    const fullDir = path10.resolve(process.cwd(), dir);
+    const fullDir = path11.resolve(process.cwd(), dir);
     try {
-      const entries = await fs12.readdir(fullDir);
+      const entries = await fs14.readdir(fullDir);
       if (entries.some((file) => file.includes(sanitized))) {
         return true;
       }
@@ -215732,8 +215732,8 @@ function gapsToEvents(_gaps) {
 }
 async function emitGapArtifacts(payload) {
   if (payload.gapOutput) {
-    const fs12 = await import("fs/promises");
-    await fs12.writeFile(payload.gapOutput, JSON.stringify(payload, null, 2));
+    const fs14 = await import("fs/promises");
+    await fs14.writeFile(payload.gapOutput, JSON.stringify(payload, null, 2));
   } else {
     console.log(JSON.stringify(payload, null, 2));
   }
@@ -215914,14 +215914,14 @@ async function reverseCommand(options) {
   }
 }
 async function writeContractToFile(contract, outputDir, format) {
-  const fs12 = await import("fs/promises");
-  const path10 = await import("path");
+  const fs14 = await import("fs/promises");
+  const path11 = await import("path");
   const crypto2 = await import("crypto");
-  await fs12.mkdir(outputDir, { recursive: true });
+  await fs14.mkdir(outputDir, { recursive: true });
   const hash = crypto2.createHash("md5").update(contract.ruleId).digest("hex").slice(0, 6);
   const sanitized = contract.ruleId.replace(/[^a-zA-Z0-9_-]/g, "-");
   const fileName = `${sanitized}-${hash}.${format === "yaml" ? "yaml" : "json"}`;
-  const filePath = path10.join(outputDir, fileName);
+  const filePath = path11.join(outputDir, fileName);
   let content;
   if (format === "yaml") {
     const yaml = await import("js-yaml");
@@ -215929,7 +215929,7 @@ async function writeContractToFile(contract, outputDir, format) {
   } else {
     content = JSON.stringify(contract, null, 2);
   }
-  await fs12.writeFile(filePath, content);
+  await fs14.writeFile(filePath, content);
 }
 var init_reverse = __esm({
   "src/cli/commands/reverse.ts"() {
@@ -215941,6 +215941,683 @@ var init_reverse = __esm({
   }
 });
 
+// src/conversations/types.ts
+var init_types3 = __esm({
+  "src/conversations/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/conversations/capture.ts
+function captureConversation(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: (0, import_node_crypto2.randomUUID)(),
+    timestamp: now,
+    turns: input.turns.map((turn) => ({
+      role: turn.role,
+      content: turn.content,
+      timestamp: turn.timestamp || now,
+      metadata: {}
+    })),
+    metadata: {
+      source: input.metadata?.source || "unknown",
+      userId: input.metadata?.userId,
+      sessionId: input.metadata?.sessionId,
+      tags: input.metadata?.tags || []
+    },
+    redacted: false,
+    normalized: false,
+    classified: false
+  };
+}
+function loadConversation(json) {
+  const data = JSON.parse(json);
+  if (!data.id || !data.timestamp || !data.turns || !data.metadata) {
+    throw new Error("Invalid conversation JSON: missing required fields");
+  }
+  return data;
+}
+var import_node_crypto2;
+var init_capture = __esm({
+  "src/conversations/capture.ts"() {
+    "use strict";
+    import_node_crypto2 = require("crypto");
+  }
+});
+
+// src/conversations/redact.ts
+function redactText(text) {
+  let redacted = text;
+  for (const { pattern, replacement } of PII_PATTERNS) {
+    redacted = redacted.replace(pattern, replacement);
+  }
+  return redacted;
+}
+function redactConversation(conversation) {
+  return {
+    ...conversation,
+    turns: conversation.turns.map((turn) => ({
+      ...turn,
+      content: redactText(turn.content)
+    })),
+    metadata: {
+      ...conversation.metadata,
+      // Redact userId if it looks like an email
+      userId: conversation.metadata.userId ? redactText(conversation.metadata.userId) : void 0
+    },
+    redacted: true
+  };
+}
+var PII_PATTERNS;
+var init_redact = __esm({
+  "src/conversations/redact.ts"() {
+    "use strict";
+    PII_PATTERNS = [
+      // Email addresses
+      { pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, replacement: "[EMAIL_REDACTED]" },
+      // Phone numbers (simple patterns)
+      { pattern: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g, replacement: "[PHONE_REDACTED]" },
+      // Credit card numbers (basic pattern - intentionally broad for safety)
+      { pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, replacement: "[CARD_REDACTED]" },
+      // SSN pattern
+      { pattern: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: "[SSN_REDACTED]" },
+      // IP addresses (basic pattern - may match invalid IPs like 999.999.999.999)
+      { pattern: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, replacement: "[IP_REDACTED]" }
+    ];
+  }
+});
+
+// src/conversations/normalize.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\t/g, "  ").replace(/\n{3,}/g, "\n\n").trim();
+}
+function normalizeCodeBlocks(text) {
+  return text.replace(/```(\w+)?\n/g, (_match, lang) => {
+    return lang ? `\`\`\`${lang.toLowerCase()}
+` : "```\n";
+  });
+}
+function normalizeTurn(content) {
+  let normalized = content;
+  normalized = normalizeWhitespace(normalized);
+  normalized = normalizeCodeBlocks(normalized);
+  return normalized;
+}
+function normalizeConversation(conversation) {
+  return {
+    ...conversation,
+    turns: conversation.turns.map((turn) => ({
+      ...turn,
+      content: normalizeTurn(turn.content)
+    })),
+    normalized: true
+  };
+}
+var init_normalize = __esm({
+  "src/conversations/normalize.ts"() {
+    "use strict";
+  }
+});
+
+// src/conversations/classify.ts
+function extractKeywords(text) {
+  return text.toLowerCase().split(/\s+/).map((word) => word.replace(/[^\w]/g, "")).filter((word) => word.length > 2);
+}
+function calculateScores(conversation) {
+  const scores = {};
+  const allContent = conversation.turns.map((t) => t.content).join(" ");
+  const keywords = extractKeywords(allContent);
+  const keywordSet = new Set(keywords);
+  for (const rule of CLASSIFICATION_RULES) {
+    let matchCount = 0;
+    for (const keyword of rule.keywords) {
+      if (keywordSet.has(keyword.toLowerCase())) {
+        matchCount++;
+      }
+    }
+    if (matchCount > 0) {
+      scores[rule.category] = matchCount / rule.keywords.length * rule.weight;
+    }
+  }
+  return scores;
+}
+function classifyConversation(conversation) {
+  const scores = calculateScores(conversation);
+  let bestCategory = "unknown";
+  let bestScore = 0;
+  for (const [category, score] of Object.entries(scores)) {
+    if (score > bestScore) {
+      bestScore = score;
+      bestCategory = category;
+    }
+  }
+  const classification = {
+    category: bestCategory,
+    confidence: Math.min(bestScore, 1),
+    tags: Object.entries(scores).filter(([_, score]) => score > 0.3).map(([category]) => category)
+  };
+  return {
+    ...conversation,
+    classification,
+    classified: true
+  };
+}
+var CLASSIFICATION_RULES;
+var init_classify = __esm({
+  "src/conversations/classify.ts"() {
+    "use strict";
+    CLASSIFICATION_RULES = [
+      {
+        category: "bug-report",
+        keywords: ["bug", "error", "crash", "broken", "issue", "problem", "fail", "exception"],
+        weight: 1
+      },
+      {
+        category: "feature-request",
+        keywords: ["feature", "enhancement", "add", "support", "implement", "would like", "could you"],
+        weight: 1
+      },
+      {
+        category: "question",
+        keywords: ["how", "what", "why", "when", "where", "?", "help", "question"],
+        weight: 0.8
+      },
+      {
+        category: "documentation",
+        keywords: ["docs", "documentation", "readme", "guide", "tutorial", "example"],
+        weight: 0.9
+      },
+      {
+        category: "performance",
+        keywords: ["slow", "performance", "optimize", "speed", "memory", "cpu"],
+        weight: 1
+      }
+    ];
+  }
+});
+
+// src/conversations/candidates.ts
+function generateCandidate(conversation) {
+  if (!conversation.classified || !conversation.classification) {
+    throw new Error("Conversation must be classified before generating candidates");
+  }
+  const { classification } = conversation;
+  let type = "documentation";
+  if (classification.category === "bug-report") {
+    type = "github-issue";
+  } else if (classification.category === "feature-request") {
+    type = "github-issue";
+  } else if (classification.category === "documentation") {
+    type = "documentation";
+  }
+  const firstUserTurn = conversation.turns.find((t) => t.role === "user");
+  if (!firstUserTurn) {
+    return null;
+  }
+  const title = generateTitle(firstUserTurn.content, classification.category);
+  const body = generateBody(conversation);
+  let priority = "medium";
+  if (classification.category === "bug-report" && (classification.confidence ?? 0) > 0.7) {
+    priority = "high";
+  }
+  const labels = [...new Set([classification.category, ...classification.tags || []].filter((label) => label !== void 0))];
+  return {
+    id: (0, import_node_crypto3.randomUUID)(),
+    conversationId: conversation.id,
+    type,
+    title,
+    body,
+    metadata: {
+      priority,
+      labels,
+      source: {
+        conversationId: conversation.id,
+        timestamp: conversation.timestamp
+      }
+    },
+    emitted: false
+  };
+}
+function generateTitle(content, category) {
+  const firstLine = content.split("\n")[0].trim();
+  const firstSentence = firstLine.split(/[.!?]/)[0].trim();
+  let title = firstSentence.substring(0, 80);
+  if (firstSentence.length > 80) {
+    title += "...";
+  }
+  if (category && category !== "unknown") {
+    const prefix = category.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+    title = `[${prefix}] ${title}`;
+  }
+  return title;
+}
+function generateBody(conversation) {
+  const parts = [];
+  parts.push("## Conversation Summary\n");
+  for (const turn of conversation.turns) {
+    const roleName = turn.role.charAt(0).toUpperCase() + turn.role.slice(1);
+    parts.push(`**${roleName}:**
+${turn.content}
+`);
+  }
+  if (conversation.classification) {
+    parts.push(`
+## Classification
+`);
+    parts.push(`- Category: ${conversation.classification.category}`);
+    parts.push(`- Confidence: ${(conversation.classification.confidence || 0).toFixed(2)}`);
+    if (conversation.classification.tags && conversation.classification.tags.length > 0) {
+      parts.push(`- Tags: ${conversation.classification.tags.join(", ")}`);
+    }
+  }
+  parts.push(`
+---
+*Generated from conversation ${conversation.id}*`);
+  return parts.join("\n");
+}
+var import_node_crypto3;
+var init_candidates = __esm({
+  "src/conversations/candidates.ts"() {
+    "use strict";
+    import_node_crypto3 = require("crypto");
+  }
+});
+
+// src/conversations/gate.ts
+function gateMinimumLength(candidate) {
+  const minLength = 50;
+  const passed = candidate.body.length >= minLength;
+  return {
+    name: "minimum-length",
+    passed,
+    message: passed ? "Content meets minimum length requirement" : `Content too short (${candidate.body.length} < ${minLength} chars)`
+  };
+}
+function gateValidTitle(candidate) {
+  const passed = candidate.title.length > 10 && candidate.title.length < 200;
+  return {
+    name: "valid-title",
+    passed,
+    message: passed ? "Title is valid" : "Title length must be between 10 and 200 characters"
+  };
+}
+function gateNotDuplicate(_candidate) {
+  return {
+    name: "not-duplicate",
+    passed: true,
+    message: "Duplicate check passed (stub)"
+  };
+}
+function gateHasMetadata(candidate) {
+  const hasLabels = !!(candidate.metadata.labels && candidate.metadata.labels.length > 0);
+  const hasPriority = !!candidate.metadata.priority;
+  const passed = hasLabels && hasPriority;
+  return {
+    name: "has-metadata",
+    passed,
+    message: passed ? "Candidate has required metadata" : "Missing labels or priority in metadata"
+  };
+}
+function applyGates(candidate) {
+  const gates = [
+    gateMinimumLength(candidate),
+    gateValidTitle(candidate),
+    gateNotDuplicate(candidate),
+    gateHasMetadata(candidate)
+  ];
+  const allPassed = gates.every((g) => g.passed);
+  const failedGates = gates.filter((g) => !g.passed);
+  const gateStatus = {
+    passed: allPassed,
+    reason: allPassed ? "All gates passed" : `Failed gates: ${failedGates.map((g) => g.name).join(", ")}`,
+    gates
+  };
+  return {
+    ...candidate,
+    gateStatus
+  };
+}
+function candidatePassed(candidate) {
+  return candidate.gateStatus?.passed || false;
+}
+var init_gate = __esm({
+  "src/conversations/gate.ts"() {
+    "use strict";
+  }
+});
+
+// src/conversations/emitters/fs.ts
+async function emitToFS(candidate, options) {
+  const { outputDir, dryRun = false } = options;
+  if (dryRun) {
+    console.log(`[DRY RUN] Would emit candidate ${candidate.id} to ${outputDir}`);
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: {
+        success: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        externalId: `fs://${outputDir}/${candidate.id}.json`
+      }
+    };
+  }
+  try {
+    await import_node_fs3.promises.mkdir(outputDir, { recursive: true });
+    const filename = `${candidate.id}.json`;
+    const filepath = import_node_path3.default.join(outputDir, filename);
+    await import_node_fs3.promises.writeFile(filepath, JSON.stringify(candidate, null, 2), "utf-8");
+    const result = {
+      success: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      externalId: `fs://${filepath}`
+    };
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: result
+    };
+  } catch (error) {
+    const result = {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+    return {
+      ...candidate,
+      emitted: false,
+      emissionResult: result
+    };
+  }
+}
+var import_node_fs3, import_node_path3;
+var init_fs = __esm({
+  "src/conversations/emitters/fs.ts"() {
+    "use strict";
+    import_node_fs3 = require("fs");
+    import_node_path3 = __toESM(require("path"), 1);
+  }
+});
+
+// src/conversations/emitters/github.ts
+async function emitToGitHub(candidate, options) {
+  const { owner, repo, token, dryRun = false, commitIntent = false } = options;
+  if (!commitIntent) {
+    const result = {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: "GATE FAILURE: commit_intent must be explicitly set to true for GitHub emission"
+    };
+    console.error(`[GATE BLOCKED] ${result.error}`);
+    return {
+      ...candidate,
+      emitted: false,
+      emissionResult: result
+    };
+  }
+  if (dryRun) {
+    console.log(`[DRY RUN] Would create GitHub issue in ${owner}/${repo}`);
+    console.log(`Title: ${candidate.title}`);
+    console.log(`Labels: ${candidate.metadata.labels?.join(", ") || "none"}`);
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: {
+        success: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        externalId: `github://${owner}/${repo}/issues/DRY_RUN`
+      }
+    };
+  }
+  try {
+    if (!owner || !repo) {
+      throw new Error("GitHub owner and repo are required");
+    }
+    if (!token) {
+      throw new Error("GitHub token is required for emission");
+    }
+    const issueData = {
+      title: candidate.title,
+      body: candidate.body,
+      labels: candidate.metadata.labels || [],
+      assignees: candidate.metadata.assignees || []
+    };
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues`, {
+      method: "POST",
+      headers: {
+        "Authorization": `token ${token}`,
+        "Accept": "application/vnd.github.v3+json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(issueData)
+    });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(`GitHub API error: ${errorData.message || response.statusText}`);
+    }
+    const issue = await response.json();
+    const result = {
+      success: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      externalId: `github://${owner}/${repo}/issues/${issue.number}`
+    };
+    console.log(`\u2713 Created GitHub issue #${issue.number}: ${issue.html_url}`);
+    return {
+      ...candidate,
+      emitted: true,
+      emissionResult: result
+    };
+  } catch (error) {
+    const result = {
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+    console.error(`\u2717 Failed to create GitHub issue: ${result.error}`);
+    return {
+      ...candidate,
+      emitted: false,
+      emissionResult: result
+    };
+  }
+}
+var init_github = __esm({
+  "src/conversations/emitters/github.ts"() {
+    "use strict";
+  }
+});
+
+// src/conversations/index.ts
+var init_conversations = __esm({
+  "src/conversations/index.ts"() {
+    "use strict";
+    init_types3();
+    init_capture();
+    init_redact();
+    init_normalize();
+    init_classify();
+    init_candidates();
+    init_gate();
+    init_fs();
+    init_github();
+    init_capture();
+    init_redact();
+    init_normalize();
+    init_classify();
+    init_candidates();
+    init_gate();
+    init_fs();
+    init_github();
+  }
+});
+
+// src/cli/commands/conversations.ts
+var conversations_exports = {};
+__export(conversations_exports, {
+  captureCommand: () => captureCommand,
+  classifyCommand: () => classifyCommand,
+  emitCommand: () => emitCommand,
+  pushCommand: () => pushCommand
+});
+async function captureCommand(options) {
+  console.log("\u{1F4DD} Capturing conversation...");
+  let conversation;
+  if (options.input) {
+    const content = await import_node_fs4.promises.readFile(options.input, "utf-8");
+    conversation = loadConversation(content);
+    console.log(`\u2713 Loaded conversation from ${options.input}`);
+  } else {
+    conversation = captureConversation({
+      turns: [
+        { role: "user", content: "Hello, I have a question about the feature" },
+        { role: "assistant", content: "Sure, I'd be happy to help!" }
+      ],
+      metadata: {
+        source: "cli"
+      }
+    });
+    console.log("\u2713 Created sample conversation");
+  }
+  if (options.output) {
+    await import_node_fs4.promises.writeFile(
+      options.output,
+      JSON.stringify(conversation, null, 2),
+      "utf-8"
+    );
+    console.log(`\u2713 Saved to ${options.output}`);
+  } else {
+    console.log(JSON.stringify(conversation, null, 2));
+  }
+}
+async function pushCommand(options) {
+  console.log("\u{1F504} Processing conversation through pipeline...");
+  const content = await import_node_fs4.promises.readFile(options.input, "utf-8");
+  let conversation = loadConversation(content);
+  console.log(`\u2713 Loaded conversation ${conversation.id}`);
+  if (!options.skipRedaction) {
+    conversation = redactConversation(conversation);
+    console.log("\u2713 Redacted PII");
+  }
+  if (!options.skipNormalization) {
+    conversation = normalizeConversation(conversation);
+    console.log("\u2713 Normalized content");
+  }
+  if (options.output) {
+    await import_node_fs4.promises.writeFile(
+      options.output,
+      JSON.stringify(conversation, null, 2),
+      "utf-8"
+    );
+    console.log(`\u2713 Saved to ${options.output}`);
+  } else {
+    console.log(JSON.stringify(conversation, null, 2));
+  }
+}
+async function classifyCommand(options) {
+  console.log("\u{1F3F7}\uFE0F  Classifying conversation...");
+  const content = await import_node_fs4.promises.readFile(options.input, "utf-8");
+  let conversation = loadConversation(content);
+  console.log(`\u2713 Loaded conversation ${conversation.id}`);
+  if (!conversation.redacted) {
+    conversation = redactConversation(conversation);
+    console.log("\u2713 Applied redaction");
+  }
+  if (!conversation.normalized) {
+    conversation = normalizeConversation(conversation);
+    console.log("\u2713 Applied normalization");
+  }
+  conversation = classifyConversation(conversation);
+  console.log(`\u2713 Classified as: ${conversation.classification?.category} (confidence: ${conversation.classification?.confidence?.toFixed(2)})`);
+  const candidate = generateCandidate(conversation);
+  if (!candidate) {
+    console.error("\u2717 Failed to generate candidate");
+    process.exit(1);
+  }
+  console.log(`\u2713 Generated candidate: ${candidate.title}`);
+  const gatedCandidate = applyGates(candidate);
+  console.log(`
+\u{1F4CB} Gate Results:`);
+  for (const gate of gatedCandidate.gateStatus?.gates || []) {
+    const icon = gate.passed ? "\u2713" : "\u2717";
+    console.log(`  ${icon} ${gate.name}: ${gate.message}`);
+  }
+  const passed = candidatePassed(gatedCandidate);
+  console.log(`
+${passed ? "\u2713 All gates passed" : "\u2717 Some gates failed"}`);
+  if (options.output) {
+    await import_node_fs4.promises.writeFile(
+      options.output,
+      JSON.stringify(gatedCandidate, null, 2),
+      "utf-8"
+    );
+    console.log(`\u2713 Saved candidate to ${options.output}`);
+  } else {
+    console.log("\n" + JSON.stringify(gatedCandidate, null, 2));
+  }
+}
+async function emitCommand(options) {
+  console.log("\u{1F4E4} Emitting candidate...");
+  const content = await import_node_fs4.promises.readFile(options.input, "utf-8");
+  const candidate = JSON.parse(content);
+  console.log(`\u2713 Loaded candidate ${candidate.id}`);
+  if (!candidatePassed(candidate)) {
+    console.error("\u2717 Candidate did not pass gates, refusing to emit");
+    console.error(`  Reason: ${candidate.gateStatus?.reason}`);
+    process.exit(1);
+  }
+  let result;
+  if (options.emitter === "fs") {
+    const outputDir = options.outputDir || "./output/candidates";
+    result = await emitToFS(candidate, {
+      outputDir,
+      dryRun: options.dryRun
+    });
+    if (result.emissionResult?.success) {
+      console.log(`\u2713 Emitted to filesystem: ${result.emissionResult.externalId}`);
+    } else {
+      console.error(`\u2717 Emission failed: ${result.emissionResult?.error}`);
+      process.exit(1);
+    }
+  } else if (options.emitter === "github") {
+    if (!options.owner || !options.repo) {
+      console.error("\u2717 GitHub emitter requires --owner and --repo");
+      process.exit(1);
+    }
+    if (!options.commitIntent) {
+      console.error("");
+      console.error("\u26D4 GATE BLOCKED: commit_intent=false");
+      console.error("");
+      console.error("The GitHub emitter is HARD GATED by the --commit-intent flag.");
+      console.error("This prevents accidental issue creation.");
+      console.error("");
+      console.error("To emit to GitHub, add: --commit-intent");
+      console.error("");
+      process.exit(1);
+    }
+    result = await emitToGitHub(candidate, {
+      owner: options.owner,
+      repo: options.repo,
+      token: options.token,
+      dryRun: options.dryRun,
+      commitIntent: options.commitIntent
+    });
+    if (result.emissionResult?.success) {
+      console.log(`\u2713 Emitted to GitHub: ${result.emissionResult.externalId}`);
+    } else {
+      console.error(`\u2717 Emission failed: ${result.emissionResult?.error}`);
+      process.exit(1);
+    }
+  }
+}
+var import_node_fs4;
+var init_conversations2 = __esm({
+  "src/cli/commands/conversations.ts"() {
+    "use strict";
+    import_node_fs4 = require("fs");
+    init_conversations();
+  }
+});
+
 // src/cli/index.ts
 var import_commander = require("commander");
 
@@ -217160,6 +217837,43 @@ program.command("reverse").description("Reverse engineer contracts from existing
     process.exit(1);
   }
 });
+var conversationsCmd = program.command("conversations").description("Conversation ingestion subsystem (capture -> redact -> normalize -> classify -> emit)");
+conversationsCmd.command("capture").description("Capture a conversation from input").option("-i, --input <file>", "Input conversation file").option("-o, --output <file>", "Output file for captured conversation").action(async (options) => {
+  try {
+    const { captureCommand: captureCommand2 } = await Promise.resolve().then(() => (init_conversations2(), conversations_exports));
+    await captureCommand2(options);
+  } catch (error) {
+    console.error("Error capturing conversation:", error);
+    process.exit(1);
+  }
+});
+conversationsCmd.command("push").description("Process conversation through pipeline (redact -> normalize)").requiredOption("-i, --input <file>", "Input conversation file").option("-o, --output <file>", "Output file for processed conversation").option("--skip-redaction", "Skip PII redaction", false).option("--skip-normalization", "Skip normalization", false).action(async (options) => {
+  try {
+    const { pushCommand: pushCommand2 } = await Promise.resolve().then(() => (init_conversations2(), conversations_exports));
+    await pushCommand2(options);
+  } catch (error) {
+    console.error("Error processing conversation:", error);
+    process.exit(1);
+  }
+});
+conversationsCmd.command("classify").description("Classify conversation and generate candidate").requiredOption("-i, --input <file>", "Input conversation file").option("-o, --output <file>", "Output file for candidate").action(async (options) => {
+  try {
+    const { classifyCommand: classifyCommand2 } = await Promise.resolve().then(() => (init_conversations2(), conversations_exports));
+    await classifyCommand2(options);
+  } catch (error) {
+    console.error("Error classifying conversation:", error);
+    process.exit(1);
+  }
+});
+conversationsCmd.command("emit").description("Emit candidate to destination (fs or github)").requiredOption("-i, --input <file>", "Input candidate file").requiredOption("-e, --emitter <type>", "Emitter type (fs, github)").option("--output-dir <dir>", "Output directory (for fs emitter)", "./output/candidates").option("--owner <owner>", "GitHub repository owner (for github emitter)").option("--repo <repo>", "GitHub repository name (for github emitter)").option("--token <token>", "GitHub token (for github emitter)").option("--dry-run", "Dry run mode (no actual emission)", false).option("--commit-intent", "REQUIRED: Explicit commit intent for GitHub emission", false).action(async (options) => {
+  try {
+    const { emitCommand: emitCommand2 } = await Promise.resolve().then(() => (init_conversations2(), conversations_exports));
+    await emitCommand2(options);
+  } catch (error) {
+    console.error("Error emitting candidate:", error);
+    process.exit(1);
+  }
+});
 program.parse();
 /*! Bundled license information: