typescript 5.1.0-dev.20230301 → 5.1.0-dev.20230302

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230301`;
+      version = `${versionMajorMinor}.0-dev.20230302`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -1622,7 +1622,7 @@ var ts = (() => {
   function isNodeLikeSystem() {
     return typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object";
   }
-  var emptyArray, emptyMap, emptySet, SortKind, elementAt, hasOwnProperty, noopPush, fileNameLowerCaseRegExp, AssertionLevel, createUIStringComparer, uiComparerCaseSensitive, uiLocale, trimString, trimStringEnd, trimStringStart;
+  var emptyArray, emptyMap, emptySet, SortKind, elementAt, hasOwnProperty, fileNameLowerCaseRegExp, AssertionLevel, createUIStringComparer, uiComparerCaseSensitive, uiLocale, trimString, trimStringEnd, trimStringStart;
   var init_core = __esm({
     "src/compiler/core.ts"() {
       "use strict";
@@ -1647,10 +1647,6 @@ var ts = (() => {
         return void 0;
       };
       hasOwnProperty = Object.prototype.hasOwnProperty;
-      noopPush = {
-        push: noop,
-        length: 0
-      };
       fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
       AssertionLevel = /* @__PURE__ */ ((AssertionLevel2) => {
         AssertionLevel2[AssertionLevel2["None"] = 0] = "None";
@@ -8458,6 +8454,7 @@ ${lanes.join("\n")}
         File_name_0_has_a_1_extension_looking_up_2_instead: diag(6262, 3 /* Message */, "File_name_0_has_a_1_extension_looking_up_2_instead_6262", "File name '{0}' has a '{1}' extension - looking up '{2}' instead."),
         Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set: diag(6263, 1 /* Error */, "Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set_6263", "Module '{0}' was resolved to '{1}', but '--allowArbitraryExtensions' is not set."),
         Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present: diag(6264, 3 /* Message */, "Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present_6264", "Enable importing files with any extension, provided a declaration file is present."),
+        Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder: diag(6265, 3 /* Message */, "Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_no_6265", "Resolving type reference directive for program that specifies custom typeRoots, skipping lookup in 'node_modules' folder."),
         Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, 3 /* Message */, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
         Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, 3 /* Message */, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
         Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, 3 /* Message */, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -8853,6 +8850,8 @@ ${lanes.join("\n")}
         This_may_be_converted_to_an_async_function: diag(80006, 2 /* Suggestion */, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."),
         await_has_no_effect_on_the_type_of_this_expression: diag(80007, 2 /* Suggestion */, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."),
         Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, 2 /* Suggestion */, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."),
+        JSDoc_typedef_may_be_converted_to_TypeScript_type: diag(80009, 2 /* Suggestion */, "JSDoc_typedef_may_be_converted_to_TypeScript_type_80009", "JSDoc typedef may be converted to TypeScript type."),
+        JSDoc_typedefs_may_be_converted_to_TypeScript_types: diag(80010, 2 /* Suggestion */, "JSDoc_typedefs_may_be_converted_to_TypeScript_types_80010", "JSDoc typedefs may be converted to TypeScript types."),
         Add_missing_super_call: diag(90001, 3 /* Message */, "Add_missing_super_call_90001", "Add missing 'super()' call"),
         Make_super_call_the_first_statement_in_the_constructor: diag(90002, 3 /* Message */, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"),
         Change_extends_to_implements: diag(90003, 3 /* Message */, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"),
@@ -9067,6 +9066,8 @@ ${lanes.join("\n")}
         Rename_param_tag_name_0_to_1: diag(95173, 3 /* Message */, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
         Use_0: diag(95174, 3 /* Message */, "Use_0_95174", "Use `{0}`."),
         Use_Number_isNaN_in_all_conditions: diag(95175, 3 /* Message */, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."),
+        Convert_typedef_to_TypeScript_type: diag(95176, 3 /* Message */, "Convert_typedef_to_TypeScript_type_95176", "Convert typedef to TypeScript type."),
+        Convert_all_typedef_to_TypeScript_types: diag(95177, 3 /* Message */, "Convert_all_typedef_to_TypeScript_types_95177", "Convert all typedef to TypeScript types."),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -38853,20 +38854,14 @@ ${lanes.join("\n")}
       currentDirectory = host.getCurrentDirectory();
     }
     if (currentDirectory !== void 0) {
-      return getDefaultTypeRoots(currentDirectory, host);
+      return getDefaultTypeRoots(currentDirectory);
     }
   }
-  function getDefaultTypeRoots(currentDirectory, host) {
-    if (!host.directoryExists) {
-      return [combinePaths(currentDirectory, nodeModulesAtTypes)];
-    }
+  function getDefaultTypeRoots(currentDirectory) {
     let typeRoots;
     forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => {
       const atTypes = combinePaths(directory, nodeModulesAtTypes);
-      if (host.directoryExists(atTypes)) {
-        (typeRoots || (typeRoots = [])).push(atTypes);
-      }
-      return void 0;
+      (typeRoots != null ? typeRoots : typeRoots = []).push(atTypes);
     });
     return typeRoots;
   }
@@ -39002,10 +38997,22 @@ ${lanes.join("\n")}
         }
         return firstDefined(typeRoots, (typeRoot) => {
           const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
-          const candidateDirectory = getDirectoryPath(candidate);
-          const directoryExists = directoryProbablyExists(candidateDirectory, host);
+          const directoryExists = directoryProbablyExists(typeRoot, host);
           if (!directoryExists && traceEnabled) {
-            trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+            trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
+          }
+          if (options.typeRoots) {
+            const resolvedFromFile = loadModuleFromFile(4 /* Declaration */, candidate, !directoryExists, moduleResolutionState);
+            if (resolvedFromFile) {
+              const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);
+              const packageInfo = packageDirectory ? getPackageJsonInfo(
+                packageDirectory,
+                /*onlyRecordFailures*/
+                false,
+                moduleResolutionState
+              ) : void 0;
+              return resolvedTypeScriptOnly(withPackageId(packageInfo, resolvedFromFile));
+            }
           }
           return resolvedTypeScriptOnly(
             loadNodeModuleFromDirectory(
@@ -39025,33 +39032,37 @@ ${lanes.join("\n")}
     function secondaryLookup() {
       const initialLocationForSecondaryLookup = containingFile && getDirectoryPath(containingFile);
       if (initialLocationForSecondaryLookup !== void 0) {
-        if (traceEnabled) {
-          trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
-        }
         let result2;
-        if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
-          const searchResult = loadModuleFromNearestNodeModulesDirectory(
-            4 /* Declaration */,
-            typeReferenceDirectiveName,
-            initialLocationForSecondaryLookup,
-            moduleResolutionState,
-            /*cache*/
-            void 0,
-            /*redirectedReference*/
-            void 0
-          );
-          result2 = searchResult && searchResult.value;
-        } else {
-          const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
-          result2 = nodeLoadModuleByRelativeName(
-            4 /* Declaration */,
-            candidate,
-            /*onlyRecordFailures*/
-            false,
-            moduleResolutionState,
-            /*considerPackageJson*/
-            true
-          );
+        if (!options.typeRoots || !endsWith(containingFile, inferredTypesContainingFile)) {
+          if (traceEnabled) {
+            trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
+          }
+          if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
+            const searchResult = loadModuleFromNearestNodeModulesDirectory(
+              4 /* Declaration */,
+              typeReferenceDirectiveName,
+              initialLocationForSecondaryLookup,
+              moduleResolutionState,
+              /*cache*/
+              void 0,
+              /*redirectedReference*/
+              void 0
+            );
+            result2 = searchResult && searchResult.value;
+          } else {
+            const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
+            result2 = nodeLoadModuleByRelativeName(
+              4 /* Declaration */,
+              candidate,
+              /*onlyRecordFailures*/
+              false,
+              moduleResolutionState,
+              /*considerPackageJson*/
+              true
+            );
+          }
+        } else if (traceEnabled) {
+          trace(host, Diagnostics.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder);
         }
         return resolvedTypeScriptOnly(result2);
       } else {
@@ -39870,6 +39881,9 @@ ${lanes.join("\n")}
           }
           resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
         }
+        if (extensions2 & 4 /* Declaration */) {
+          resolved2 != null ? resolved2 : resolved2 = resolveFromTypeRoot(moduleName, state2);
+        }
         return resolved2 && { value: resolved2.value && { resolved: resolved2.value, isExternalLibraryImport: true } };
       } else {
         const { path: candidate, parts } = normalizePathForCJSResolution(containingDirectory, moduleName);
@@ -40049,6 +40063,7 @@ ${lanes.join("\n")}
     return forEach(state.compilerOptions.moduleSuffixes, (suffix) => tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state));
   }
   function tryFileLookup(fileName, onlyRecordFailures, state) {
+    var _a2;
     if (!onlyRecordFailures) {
       if (state.host.fileExists(fileName)) {
         if (state.traceEnabled) {
@@ -40061,7 +40076,7 @@ ${lanes.join("\n")}
         }
       }
     }
-    state.failedLookupLocations.push(fileName);
+    (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(fileName);
     return void 0;
   }
   function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
@@ -40176,8 +40191,8 @@ ${lanes.join("\n")}
       host,
       compilerOptions: options,
       traceEnabled: isTraceEnabled(options, host),
-      failedLookupLocations: noopPush,
-      affectingLocations: noopPush,
+      failedLookupLocations: void 0,
+      affectingLocations: void 0,
       packageJsonInfoCache,
       features: 0 /* None */,
       conditions: emptyArray,
@@ -40211,24 +40226,24 @@ ${lanes.join("\n")}
     return packageJsonInfo.contents.versionPaths || void 0;
   }
   function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
-    var _a2, _b, _c;
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
     const { host, traceEnabled } = state;
     const packageJsonPath = combinePaths(packageDirectory, "package.json");
     if (onlyRecordFailures) {
-      state.failedLookupLocations.push(packageJsonPath);
+      (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(packageJsonPath);
       return void 0;
     }
-    const existing = (_a2 = state.packageJsonInfoCache) == null ? void 0 : _a2.getPackageJsonInfo(packageJsonPath);
+    const existing = (_b = state.packageJsonInfoCache) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
     if (existing !== void 0) {
       if (typeof existing !== "boolean") {
         if (traceEnabled)
           trace(host, Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
-        state.affectingLocations.push(packageJsonPath);
+        (_c = state.affectingLocations) == null ? void 0 : _c.push(packageJsonPath);
         return existing.packageDirectory === packageDirectory ? existing : { packageDirectory, contents: existing.contents };
       } else {
         if (existing && traceEnabled)
           trace(host, Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath);
-        state.failedLookupLocations.push(packageJsonPath);
+        (_d = state.failedLookupLocations) == null ? void 0 : _d.push(packageJsonPath);
         return void 0;
       }
     }
@@ -40239,15 +40254,15 @@ ${lanes.join("\n")}
         trace(host, Diagnostics.Found_package_json_at_0, packageJsonPath);
       }
       const result = { packageDirectory, contents: { packageJsonContent, versionPaths: void 0, resolvedEntrypoints: void 0 } };
-      (_b = state.packageJsonInfoCache) == null ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
-      state.affectingLocations.push(packageJsonPath);
+      (_e = state.packageJsonInfoCache) == null ? void 0 : _e.setPackageJsonInfo(packageJsonPath, result);
+      (_f = state.affectingLocations) == null ? void 0 : _f.push(packageJsonPath);
       return result;
     } else {
       if (directoryExists && traceEnabled) {
         trace(host, Diagnostics.File_0_does_not_exist, packageJsonPath);
       }
-      (_c = state.packageJsonInfoCache) == null ? void 0 : _c.setPackageJsonInfo(packageJsonPath, directoryExists);
-      state.failedLookupLocations.push(packageJsonPath);
+      (_g = state.packageJsonInfoCache) == null ? void 0 : _g.setPackageJsonInfo(packageJsonPath, directoryExists);
+      (_h = state.failedLookupLocations) == null ? void 0 : _h.push(packageJsonPath);
     }
   }
   function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
@@ -41067,11 +41082,13 @@ ${lanes.join("\n")}
             state
           ));
         });
-        if (resolved2) {
+        if (resolved2)
           return resolved2;
-        }
         if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
-          return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+          let resolved3 = loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+          if (extensions & 4 /* Declaration */)
+            resolved3 != null ? resolved3 : resolved3 = resolveFromTypeRoot(moduleName, state);
+          return resolved3;
         }
       } else {
         const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
@@ -41085,6 +41102,31 @@ ${lanes.join("\n")}
       }
     }
   }
+  function resolveFromTypeRoot(moduleName, state) {
+    if (!state.compilerOptions.typeRoots)
+      return;
+    for (const typeRoot of state.compilerOptions.typeRoots) {
+      const candidate = combinePaths(typeRoot, moduleName);
+      const directoryExists = directoryProbablyExists(typeRoot, state.host);
+      if (!directoryExists && state.traceEnabled) {
+        trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
+      }
+      const resolvedFromFile = loadModuleFromFile(4 /* Declaration */, candidate, !directoryExists, state);
+      if (resolvedFromFile) {
+        const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);
+        const packageInfo = packageDirectory ? getPackageJsonInfo(
+          packageDirectory,
+          /*onlyRecordFailures*/
+          false,
+          state
+        ) : void 0;
+        return toSearchResult(withPackageId(packageInfo, resolvedFromFile));
+      }
+      const resolved = loadNodeModuleFromDirectory(4 /* Declaration */, candidate, !directoryExists, state);
+      if (resolved)
+        return toSearchResult(resolved);
+    }
+  }
   function shouldAllowImportingTsExtension(compilerOptions, fromFileName) {
     return !!compilerOptions.allowImportingTsExtensions || fromFileName && isDeclarationFileName(fromFileName);
   }
@@ -54007,7 +54049,11 @@ ${lanes.join("\n")}
         const baseTypeVariable = getBaseTypeVariableOfClass(symbol);
         return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
       } else {
-        return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(type) : type;
+        return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(
+          type,
+          /*isProperty*/
+          true
+        ) : type;
       }
     }
     function getTypeOfEnumMember(symbol) {
@@ -62708,6 +62754,7 @@ ${lanes.join("\n")}
         } else if (targetFlags & 8388608 /* IndexedAccess */) {
           if (sourceFlags & 8388608 /* IndexedAccess */) {
             if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, reportErrors2)) {
+              instantiateType(source2.objectType, reportUnreliableMapper);
               result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, reportErrors2);
             }
             if (result2) {
@@ -65853,7 +65900,7 @@ ${lanes.join("\n")}
       );
     }
     function isInAmbientOrTypeNode(node) {
-      return !!(node.flags & 16777216 /* Ambient */ || findAncestor(node, (n) => isInterfaceDeclaration(n) || isTypeLiteralNode(n)));
+      return !!(node.flags & 16777216 /* Ambient */ || findAncestor(node, (n) => isInterfaceDeclaration(n) || isTypeAliasDeclaration(n) || isTypeLiteralNode(n)));
     }
     function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
       switch (node.kind) {
@@ -69001,6 +69048,16 @@ ${lanes.join("\n")}
           const symbol = getSymbolOfDeclaration(element);
           return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
         }
+        if (hasDynamicName(element)) {
+          const name = getNameOfDeclaration(element);
+          if (name && isComputedPropertyName(name)) {
+            const exprType = checkExpression(name.expression);
+            const propType = isTypeUsableAsPropertyName(exprType) && getTypeOfPropertyOfContextualType(type, getPropertyNameFromType(exprType));
+            if (propType) {
+              return propType;
+            }
+          }
+        }
         if (element.name) {
           const nameType = getLiteralTypeFromPropertyName(element.name);
           return mapType(
@@ -73774,7 +73831,7 @@ ${lanes.join("\n")}
     }
     function getNonArrayRestType(signature) {
       const restType = getEffectiveRestType(signature);
-      return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072 /* Never */) === 0 ? restType : void 0;
+      return restType && !isArrayType(restType) && !isTypeAny(restType) ? restType : void 0;
     }
     function getTypeOfFirstParameterOfSignature(signature) {
       return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType);
@@ -78588,6 +78645,9 @@ ${lanes.join("\n")}
         return;
       }
       if (isBindingPattern(node.name)) {
+        if (isInAmbientOrTypeNode(node)) {
+          return;
+        }
         const needCheckInitializer = hasOnlyExpressionInitializer(node) && node.initializer && node.parent.parent.kind !== 246 /* ForInStatement */;
         const needCheckWidenedType = !some(node.name.elements, not(isOmittedExpression));
         if (needCheckInitializer || needCheckWidenedType) {
@@ -121573,7 +121633,7 @@ ${lanes.join("\n")}
       return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : void 0;
     }
     function createTypeRootsWatch(typeRootPath, typeRoot) {
-      return resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
+      return canWatchTypeRootPath(typeRootPath) ? resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
         const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
         if (cachedDirectoryStructureHost) {
           cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
@@ -121584,7 +121644,7 @@ ${lanes.join("\n")}
         if (dirPath) {
           scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
         }
-      }, 1 /* Recursive */);
+      }, 1 /* Recursive */) : noopFileWatcher;
     }
     function updateTypeRootsWatch() {
       const options = resolutionHost.getCompilationSettings();
@@ -121592,7 +121652,7 @@ ${lanes.join("\n")}
         closeTypeRootsWatch();
         return;
       }
-      const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
+      const typeRoots = getEffectiveTypeRoots(options, { getCurrentDirectory });
       if (typeRoots) {
         mutateMap(
           typeRootsWatches,
@@ -121606,7 +121666,9 @@ ${lanes.join("\n")}
         closeTypeRootsWatch();
       }
     }
-    function directoryExistsForTypeRootWatch(nodeTypesDirectory) {
+    function canWatchTypeRootPath(nodeTypesDirectory) {
+      if (resolutionHost.getCompilationSettings().typeRoots)
+        return true;
       const dir = getDirectoryPath(getDirectoryPath(nodeTypesDirectory));
       const dirPath = resolutionHost.toPath(dir);
       return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
@@ -131635,6 +131697,10 @@ ${lanes.join("\n")}
             diags.push(createDiagnosticForNode(init, Diagnostics.require_call_may_be_converted_to_an_import));
           }
         }
+        const jsdocTypedefNode = ts_codefix_exports.getJSDocTypedefNode(node);
+        if (jsdocTypedefNode) {
+          diags.push(createDiagnosticForNode(jsdocTypedefNode, Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type));
+        }
         if (ts_codefix_exports.parameterShouldGetTypeFromJSDoc(node)) {
           diags.push(createDiagnosticForNode(node.name || node, Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types));
         }
@@ -133450,18 +133516,6 @@ ${lanes.join("\n")}
       synchronizeHostData();
       return ts_FindAllReferences_exports.getImplementationsAtPosition(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
     }
-    function getOccurrencesAtPosition(fileName, position) {
-      return flatMap(
-        getDocumentHighlights(fileName, position, [fileName]),
-        (entry) => entry.highlightSpans.map((highlightSpan) => ({
-          fileName: entry.fileName,
-          textSpan: highlightSpan.textSpan,
-          isWriteAccess: highlightSpan.kind === "writtenReference" /* writtenReference */,
-          ...highlightSpan.isInString && { isInString: true },
-          ...highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan }
-        }))
-      );
-    }
     function getDocumentHighlights(fileName, position, filesToSearch) {
       const normalizedFileName = normalizePath(fileName);
       Debug.assert(filesToSearch.some((f) => normalizePath(f) === normalizedFileName));
@@ -133654,22 +133708,22 @@ ${lanes.join("\n")}
       }
       return [];
     }
-    function getCodeFixesAtPosition(fileName, start, end, errorCodes63, formatOptions, preferences = emptyOptions) {
+    function getCodeFixesAtPosition(fileName, start, end, errorCodes64, formatOptions, preferences = emptyOptions) {
       synchronizeHostData();
       const sourceFile = getValidSourceFile(fileName);
       const span = createTextSpanFromBounds(start, end);
       const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-      return flatMap(deduplicate(errorCodes63, equateValues, compareValues), (errorCode) => {
+      return flatMap(deduplicate(errorCodes64, equateValues, compareValues), (errorCode) => {
         cancellationToken.throwIfCancellationRequested();
         return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
       });
     }
-    function getCombinedCodeFix(scope, fixId51, formatOptions, preferences = emptyOptions) {
+    function getCombinedCodeFix(scope, fixId52, formatOptions, preferences = emptyOptions) {
       synchronizeHostData();
       Debug.assert(scope.type === "file");
       const sourceFile = getValidSourceFile(scope.fileName);
       const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-      return ts_codefix_exports.getAllFixes({ fixId: fixId51, sourceFile, program, host, cancellationToken, formatContext, preferences });
+      return ts_codefix_exports.getAllFixes({ fixId: fixId52, sourceFile, program, host, cancellationToken, formatContext, preferences });
     }
     function organizeImports2(args, formatOptions, preferences = emptyOptions) {
       var _a3;
@@ -134091,7 +134145,6 @@ ${lanes.join("\n")}
       getReferencesAtPosition,
       findReferences,
       getFileReferences,
-      getOccurrencesAtPosition,
       getDocumentHighlights,
       getNameOrDottedNameSpan,
       getBreakpointStatementAtPosition,
@@ -134917,7 +134970,6 @@ ${lanes.join("\n")}
         "getTypeDefinitionAtPosition",
         "getReferencesAtPosition",
         "findReferences",
-        "getOccurrencesAtPosition",
         "getDocumentHighlights",
         "getNavigateToItems",
         "getRenameInfo",
@@ -135501,12 +135553,6 @@ ${lanes.join("\n")}
             () => this.languageService.getFileReferences(fileName)
           );
         }
-        getOccurrencesAtPosition(fileName, position) {
-          return this.forwardJSONCall(
-            `getOccurrencesAtPosition('${fileName}', ${position})`,
-            () => this.languageService.getOccurrencesAtPosition(fileName, position)
-          );
-        }
         getDocumentHighlights(fileName, position, filesToSearch) {
           return this.forwardJSONCall(
             `getDocumentHighlights('${fileName}', ${position})`,
@@ -137140,23 +137186,23 @@ ${lanes.join("\n")}
       void 0
     );
   }
-  function createCodeFixAction(fixName8, changes, description2, fixId51, fixAllDescription, command) {
-    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId51, diagnosticToString(fixAllDescription), command);
+  function createCodeFixAction(fixName8, changes, description2, fixId52, fixAllDescription, command) {
+    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId52, diagnosticToString(fixAllDescription), command);
   }
-  function createCodeFixActionMaybeFixAll(fixName8, changes, description2, fixId51, fixAllDescription, command) {
-    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId51, fixAllDescription && diagnosticToString(fixAllDescription), command);
+  function createCodeFixActionMaybeFixAll(fixName8, changes, description2, fixId52, fixAllDescription, command) {
+    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId52, fixAllDescription && diagnosticToString(fixAllDescription), command);
   }
-  function createCodeFixActionWorker(fixName8, description2, changes, fixId51, fixAllDescription, command) {
-    return { fixName: fixName8, description: description2, changes, fixId: fixId51, fixAllDescription, commands: command ? [command] : void 0 };
+  function createCodeFixActionWorker(fixName8, description2, changes, fixId52, fixAllDescription, command) {
+    return { fixName: fixName8, description: description2, changes, fixId: fixId52, fixAllDescription, commands: command ? [command] : void 0 };
   }
   function registerCodeFix(reg) {
     for (const error of reg.errorCodes) {
       errorCodeToFixes.add(String(error), reg);
     }
     if (reg.fixIds) {
-      for (const fixId51 of reg.fixIds) {
-        Debug.assert(!fixIdToRegistration.has(fixId51));
-        fixIdToRegistration.set(fixId51, reg);
+      for (const fixId52 of reg.fixIds) {
+        Debug.assert(!fixIdToRegistration.has(fixId52));
+        fixIdToRegistration.set(fixId52, reg);
       }
     }
   }
@@ -137164,17 +137210,17 @@ ${lanes.join("\n")}
     return arrayFrom(errorCodeToFixes.keys());
   }
   function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
-    const { errorCodes: errorCodes63 } = registration;
+    const { errorCodes: errorCodes64 } = registration;
     let maybeFixableDiagnostics = 0;
     for (const diag2 of diagnostics) {
-      if (contains(errorCodes63, diag2.code))
+      if (contains(errorCodes64, diag2.code))
         maybeFixableDiagnostics++;
       if (maybeFixableDiagnostics > 1)
         break;
     }
     const fixAllUnavailable = maybeFixableDiagnostics < 2;
-    return ({ fixId: fixId51, fixAllDescription, ...action }) => {
-      return fixAllUnavailable ? action : { ...action, fixId: fixId51, fixAllDescription };
+    return ({ fixId: fixId52, fixAllDescription, ...action }) => {
+      return fixAllUnavailable ? action : { ...action, fixId: fixId52, fixAllDescription };
     };
   }
   function getFixes(context) {
@@ -137191,14 +137237,14 @@ ${lanes.join("\n")}
   function createFileTextChanges(fileName, textChanges2) {
     return { fileName, textChanges: textChanges2 };
   }
-  function codeFixAll(context, errorCodes63, use) {
+  function codeFixAll(context, errorCodes64, use) {
     const commands = [];
-    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes63, (diag2) => use(t, diag2, commands)));
+    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes64, (diag2) => use(t, diag2, commands)));
     return createCombinedCodeActions(changes, commands.length === 0 ? void 0 : commands);
   }
-  function eachDiagnostic(context, errorCodes63, cb) {
+  function eachDiagnostic(context, errorCodes64, cb) {
     for (const diag2 of getDiagnostics(context)) {
-      if (contains(errorCodes63, diag2.code)) {
+      if (contains(errorCodes64, diag2.code)) {
         cb(diag2);
       }
     }
@@ -139780,32 +139826,96 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/convertToTypeOnlyImport.ts
-  function getImportDeclarationForDiagnosticSpan(span, sourceFile) {
-    return tryCast(getTokenAtPosition(sourceFile, span.start).parent, isImportDeclaration);
+  function getDeclaration2(sourceFile, pos) {
+    const { parent: parent2 } = getTokenAtPosition(sourceFile, pos);
+    return isImportSpecifier(parent2) || isImportDeclaration(parent2) && parent2.importClause ? parent2 : void 0;
   }
-  function fixSingleImportDeclaration(changes, importDeclaration, context) {
-    if (!(importDeclaration == null ? void 0 : importDeclaration.importClause)) {
-      return;
-    }
-    const { importClause } = importDeclaration;
-    changes.insertText(context.sourceFile, importDeclaration.getStart() + "import".length, " type");
-    if (importClause.name && importClause.namedBindings) {
-      changes.deleteNodeRangeExcludingEnd(context.sourceFile, importClause.name, importDeclaration.importClause.namedBindings);
-      changes.insertNodeBefore(context.sourceFile, importDeclaration, factory.updateImportDeclaration(
-        importDeclaration,
-        /*modifiers*/
-        void 0,
-        factory.createImportClause(
-          /*isTypeOnly*/
-          true,
-          importClause.name,
-          /*namedBindings*/
-          void 0
-        ),
-        importDeclaration.moduleSpecifier,
-        /*assertClause*/
-        void 0
+  function doChange4(changes, sourceFile, declaration) {
+    if (isImportSpecifier(declaration)) {
+      changes.replaceNode(sourceFile, declaration, factory.updateImportSpecifier(
+        declaration,
+        /*isTypeOnly*/
+        true,
+        declaration.propertyName,
+        declaration.name
       ));
+    } else {
+      const importClause = declaration.importClause;
+      if (importClause.name && importClause.namedBindings) {
+        changes.replaceNodeWithNodes(sourceFile, declaration, [
+          factory.createImportDeclaration(
+            getSynthesizedDeepClones(
+              declaration.modifiers,
+              /*includeTrivia*/
+              true
+            ),
+            factory.createImportClause(
+              /*isTypeOnly*/
+              true,
+              getSynthesizedDeepClone(
+                importClause.name,
+                /*includeTrivia*/
+                true
+              ),
+              /*namedBindings*/
+              void 0
+            ),
+            getSynthesizedDeepClone(
+              declaration.moduleSpecifier,
+              /*includeTrivia*/
+              true
+            ),
+            getSynthesizedDeepClone(
+              declaration.assertClause,
+              /*includeTrivia*/
+              true
+            )
+          ),
+          factory.createImportDeclaration(
+            getSynthesizedDeepClones(
+              declaration.modifiers,
+              /*includeTrivia*/
+              true
+            ),
+            factory.createImportClause(
+              /*isTypeOnly*/
+              true,
+              /*name*/
+              void 0,
+              getSynthesizedDeepClone(
+                importClause.namedBindings,
+                /*includeTrivia*/
+                true
+              )
+            ),
+            getSynthesizedDeepClone(
+              declaration.moduleSpecifier,
+              /*includeTrivia*/
+              true
+            ),
+            getSynthesizedDeepClone(
+              declaration.assertClause,
+              /*includeTrivia*/
+              true
+            )
+          )
+        ]);
+      } else {
+        const importDeclaration = factory.updateImportDeclaration(
+          declaration,
+          declaration.modifiers,
+          factory.updateImportClause(
+            importClause,
+            /*isTypeOnly*/
+            true,
+            importClause.name,
+            importClause.namedBindings
+          ),
+          declaration.moduleSpecifier,
+          declaration.assertClause
+        );
+        changes.replaceNode(sourceFile, declaration, importDeclaration);
+      }
     }
   }
   var errorCodes14, fixId13;
@@ -139814,30 +139924,181 @@ ${lanes.join("\n")}
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes14 = [Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code];
+      errorCodes14 = [
+        Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code,
+        Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled.code
+      ];
       fixId13 = "convertToTypeOnlyImport";
       registerCodeFix({
         errorCodes: errorCodes14,
         getCodeActions: function getCodeActionsToConvertToTypeOnlyImport(context) {
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
-            const importDeclaration = getImportDeclarationForDiagnosticSpan(context.span, context.sourceFile);
-            fixSingleImportDeclaration(t, importDeclaration, context);
-          });
-          if (changes.length) {
+          const declaration = getDeclaration2(context.sourceFile, context.span.start);
+          if (declaration) {
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange4(t, context.sourceFile, declaration));
             return [createCodeFixAction(fixId13, changes, Diagnostics.Convert_to_type_only_import, fixId13, Diagnostics.Convert_all_imports_not_used_as_a_value_to_type_only_imports)];
           }
+          return void 0;
         },
         fixIds: [fixId13],
         getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyImport(context) {
           return codeFixAll(context, errorCodes14, (changes, diag2) => {
-            const importDeclaration = getImportDeclarationForDiagnosticSpan(diag2, context.sourceFile);
-            fixSingleImportDeclaration(changes, importDeclaration, context);
+            const declaration = getDeclaration2(diag2.file, diag2.start);
+            if (declaration) {
+              doChange4(changes, diag2.file, declaration);
+            }
           });
         }
       });
     }
   });
 
+  // src/services/codefixes/convertTypedefToType.ts
+  function doChange5(changes, node, sourceFile) {
+    if (isJSDocTypedefTag(node)) {
+      fixSingleTypeDef(changes, node, sourceFile);
+    }
+  }
+  function fixSingleTypeDef(changes, typeDefNode, sourceFile) {
+    if (!typeDefNode)
+      return;
+    const declaration = createDeclaration(typeDefNode);
+    if (!declaration)
+      return;
+    const comment = typeDefNode.parent;
+    changes.replaceNode(
+      sourceFile,
+      comment,
+      declaration
+    );
+  }
+  function createDeclaration(tag) {
+    var _a2;
+    const { typeExpression } = tag;
+    if (!typeExpression)
+      return;
+    const typeName = (_a2 = tag.name) == null ? void 0 : _a2.getText();
+    if (!typeName)
+      return;
+    if (typeExpression.kind === 325 /* JSDocTypeLiteral */) {
+      return createInterfaceForTypeLiteral(typeName, typeExpression);
+    }
+    if (typeExpression.kind === 312 /* JSDocTypeExpression */) {
+      return createTypeAliasForTypeExpression(typeName, typeExpression);
+    }
+  }
+  function createInterfaceForTypeLiteral(typeName, typeLiteral) {
+    const propertySignatures = createSignatureFromTypeLiteral(typeLiteral);
+    if (!some(propertySignatures))
+      return;
+    const interfaceDeclaration = factory.createInterfaceDeclaration(
+      /*modifiers*/
+      void 0,
+      typeName,
+      /*typeParameters*/
+      void 0,
+      /*heritageClauses*/
+      void 0,
+      propertySignatures
+    );
+    return interfaceDeclaration;
+  }
+  function createTypeAliasForTypeExpression(typeName, typeExpression) {
+    const typeReference = getSynthesizedDeepClone(typeExpression.type);
+    if (!typeReference)
+      return;
+    const declaration = factory.createTypeAliasDeclaration(
+      /*modifiers*/
+      void 0,
+      factory.createIdentifier(typeName),
+      /*typeParameters*/
+      void 0,
+      typeReference
+    );
+    return declaration;
+  }
+  function createSignatureFromTypeLiteral(typeLiteral) {
+    const propertyTags = typeLiteral.jsDocPropertyTags;
+    if (!some(propertyTags))
+      return;
+    const getSignature = (tag) => {
+      var _a2;
+      const name = getPropertyName(tag);
+      const type = (_a2 = tag.typeExpression) == null ? void 0 : _a2.type;
+      const isOptional = tag.isBracketed;
+      let typeReference;
+      if (type && isJSDocTypeLiteral(type)) {
+        const signatures = createSignatureFromTypeLiteral(type);
+        typeReference = factory.createTypeLiteralNode(signatures);
+      } else if (type) {
+        typeReference = getSynthesizedDeepClone(type);
+      }
+      if (typeReference && name) {
+        const questionToken = isOptional ? factory.createToken(57 /* QuestionToken */) : void 0;
+        const prop = factory.createPropertySignature(
+          /*modifiers*/
+          void 0,
+          name,
+          questionToken,
+          typeReference
+        );
+        return prop;
+      }
+    };
+    const props = mapDefined(propertyTags, getSignature);
+    return props;
+  }
+  function getPropertyName(tag) {
+    return tag.name.kind === 79 /* Identifier */ ? tag.name.text : tag.name.right.text;
+  }
+  function getJSDocTypedefNode(node) {
+    if (hasJSDocNodes(node)) {
+      return forEach(node.jsDoc, (node2) => {
+        var _a2;
+        return (_a2 = node2.tags) == null ? void 0 : _a2.find(isJSDocTypedefTag);
+      });
+    }
+    return void 0;
+  }
+  var fixId14, errorCodes15;
+  var init_convertTypedefToType = __esm({
+    "src/services/codefixes/convertTypedefToType.ts"() {
+      "use strict";
+      init_ts4();
+      init_ts_codefix();
+      fixId14 = "convertTypedefToType";
+      errorCodes15 = [Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type.code];
+      registerCodeFix({
+        fixIds: [fixId14],
+        errorCodes: errorCodes15,
+        getCodeActions(context) {
+          const node = getTokenAtPosition(
+            context.sourceFile,
+            context.span.start
+          );
+          if (!node)
+            return;
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange5(t, node, context.sourceFile));
+          if (changes.length > 0) {
+            return [
+              createCodeFixAction(
+                fixId14,
+                changes,
+                Diagnostics.Convert_typedef_to_TypeScript_type,
+                fixId14,
+                Diagnostics.Convert_all_typedef_to_TypeScript_types
+              )
+            ];
+          }
+        },
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes15, (changes, diag2) => {
+          const node = getTokenAtPosition(diag2.file, diag2.start);
+          if (node)
+            doChange5(changes, node, diag2.file);
+        })
+      });
+    }
+  });
+
   // src/services/codefixes/convertLiteralTypeToMappedType.ts
   function getInfo2(sourceFile, pos) {
     const token = getTokenAtPosition(sourceFile, pos);
@@ -139853,7 +140114,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  function doChange4(changes, sourceFile, { container, typeNode, constraint, name }) {
+  function doChange6(changes, sourceFile, { container, typeNode, constraint, name }) {
     changes.replaceNode(sourceFile, container, factory.createMappedTypeNode(
       /*readonlyToken*/
       void 0,
@@ -139872,16 +140133,16 @@ ${lanes.join("\n")}
       void 0
     ));
   }
-  var fixId14, errorCodes15;
+  var fixId15, errorCodes16;
   var init_convertLiteralTypeToMappedType = __esm({
     "src/services/codefixes/convertLiteralTypeToMappedType.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId14 = "convertLiteralTypeToMappedType";
-      errorCodes15 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code];
+      fixId15 = "convertLiteralTypeToMappedType";
+      errorCodes16 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code];
       registerCodeFix({
-        errorCodes: errorCodes15,
+        errorCodes: errorCodes16,
         getCodeActions: function getCodeActionsToConvertLiteralTypeToMappedType(context) {
           const { sourceFile, span } = context;
           const info = getInfo2(sourceFile, span.start);
@@ -139889,14 +140150,14 @@ ${lanes.join("\n")}
             return void 0;
           }
           const { name, constraint } = info;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange4(t, sourceFile, info));
-          return [createCodeFixAction(fixId14, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId14, Diagnostics.Convert_all_type_literals_to_mapped_type)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange6(t, sourceFile, info));
+          return [createCodeFixAction(fixId15, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId15, Diagnostics.Convert_all_type_literals_to_mapped_type)];
         },
-        fixIds: [fixId14],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes15, (changes, diag2) => {
+        fixIds: [fixId15],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes16, (changes, diag2) => {
           const info = getInfo2(diag2.file, diag2.start);
           if (info) {
-            doChange4(changes, diag2.file, info);
+            doChange6(changes, diag2.file, info);
           }
         })
       });
@@ -139955,31 +140216,31 @@ ${lanes.join("\n")}
     const heritageClauseTypeSymbols = checker.getPropertiesOfType(heritageClauseType);
     return createSymbolTable(heritageClauseTypeSymbols.filter(symbolPointsToNonPrivateMember));
   }
-  var errorCodes16, fixId15;
+  var errorCodes17, fixId16;
   var init_fixClassIncorrectlyImplementsInterface = __esm({
     "src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes16 = [
+      errorCodes17 = [
         Diagnostics.Class_0_incorrectly_implements_interface_1.code,
         Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code
       ];
-      fixId15 = "fixClassIncorrectlyImplementsInterface";
+      fixId16 = "fixClassIncorrectlyImplementsInterface";
       registerCodeFix({
-        errorCodes: errorCodes16,
+        errorCodes: errorCodes17,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const classDeclaration = getClass(sourceFile, span.start);
           return mapDefined(getEffectiveImplementsTypeNodes(classDeclaration), (implementedTypeNode) => {
             const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, t, context.preferences));
-            return changes.length === 0 ? void 0 : createCodeFixAction(fixId15, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId15, Diagnostics.Implement_all_unimplemented_interfaces);
+            return changes.length === 0 ? void 0 : createCodeFixAction(fixId16, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId16, Diagnostics.Implement_all_unimplemented_interfaces);
           });
         },
-        fixIds: [fixId15],
+        fixIds: [fixId16],
         getAllCodeActions(context) {
           const seenClassDeclarations = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes16, (changes, diag2) => {
+          return codeFixAll(context, errorCodes17, (changes, diag2) => {
             const classDeclaration = getClass(diag2.file, diag2.start);
             if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
               for (const implementedTypeNode of getEffectiveImplementsTypeNodes(classDeclaration)) {
@@ -141153,7 +141414,7 @@ ${lanes.join("\n")}
     }
     return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
   }
-  var importFixName, importFixId, errorCodes17;
+  var importFixName, importFixId, errorCodes18;
   var init_importFixes = __esm({
     "src/services/codefixes/importFixes.ts"() {
       "use strict";
@@ -141161,7 +141422,7 @@ ${lanes.join("\n")}
       init_ts_codefix();
       importFixName = "import";
       importFixId = "fixMissingImport";
-      errorCodes17 = [
+      errorCodes18 = [
         Diagnostics.Cannot_find_name_0.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
@@ -141173,7 +141434,7 @@ ${lanes.join("\n")}
         Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes17,
+        errorCodes: errorCodes18,
         getCodeActions(context) {
           const { errorCode, preferences, sourceFile, span, program } = context;
           const info = getFixInfos(
@@ -141208,7 +141469,7 @@ ${lanes.join("\n")}
             host,
             cancellationToken
           );
-          eachDiagnostic(context, errorCodes17, (diag2) => importAdder.addImportFromDiagnostic(diag2, context));
+          eachDiagnostic(context, errorCodes18, (diag2) => importAdder.addImportFromDiagnostic(diag2, context));
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, importAdder.writeFixes));
         }
       });
@@ -141283,14 +141544,14 @@ ${lanes.join("\n")}
     const contextualType = isExpression(node) ? checker.getContextualType(node) : void 0;
     return contextualType || checker.getTypeAtLocation(node);
   }
-  var fixId16, errorCodes18;
+  var fixId17, errorCodes19;
   var init_fixAddMissingConstraint = __esm({
     "src/services/codefixes/fixAddMissingConstraint.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId16 = "addMissingConstraint";
-      errorCodes18 = [
+      fixId17 = "addMissingConstraint";
+      errorCodes19 = [
         // We want errors this could be attached to:
         // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
         Diagnostics.Type_0_is_not_comparable_to_type_1.code,
@@ -141303,21 +141564,21 @@ ${lanes.join("\n")}
         Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes18,
+        errorCodes: errorCodes19,
         getCodeActions(context) {
           const { sourceFile, span, program, preferences, host } = context;
           const info = getInfo3(program, sourceFile, span);
           if (info === void 0)
             return;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingConstraint(t, program, preferences, host, sourceFile, info));
-          return [createCodeFixAction(fixId16, changes, Diagnostics.Add_extends_constraint, fixId16, Diagnostics.Add_extends_constraint_to_all_type_parameters)];
+          return [createCodeFixAction(fixId17, changes, Diagnostics.Add_extends_constraint, fixId17, Diagnostics.Add_extends_constraint_to_all_type_parameters)];
         },
-        fixIds: [fixId16],
+        fixIds: [fixId17],
         getAllCodeActions: (context) => {
           const { program, preferences, host } = context;
           const seen = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes18, (diag2) => {
+            eachDiagnostic(context, errorCodes19, (diag2) => {
               const info = getInfo3(program, diag2.file, createTextSpan(diag2.start, diag2.length));
               if (info) {
                 if (addToSeen(seen, getNodeId(info.declaration))) {
@@ -141399,7 +141660,7 @@ ${lanes.join("\n")}
     Debug.assert(classElement && isClassElementLikeHasJSDoc(classElement));
     return classElement;
   }
-  var fixName, fixAddOverrideId, fixRemoveOverrideId, errorCodes19, errorCodeFixIdMap;
+  var fixName, fixAddOverrideId, fixRemoveOverrideId, errorCodes20, errorCodeFixIdMap;
   var init_fixOverrideModifier = __esm({
     "src/services/codefixes/fixOverrideModifier.ts"() {
       "use strict";
@@ -141408,7 +141669,7 @@ ${lanes.join("\n")}
       fixName = "fixOverrideModifier";
       fixAddOverrideId = "fixAddOverrideModifier";
       fixRemoveOverrideId = "fixRemoveOverrideModifier";
-      errorCodes19 = [
+      errorCodes20 = [
         Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code,
         Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code,
         Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code,
@@ -141472,20 +141733,20 @@ ${lanes.join("\n")}
         }
       };
       registerCodeFix({
-        errorCodes: errorCodes19,
+        errorCodes: errorCodes20,
         getCodeActions: function getCodeActionsToFixOverrideModifierIssues(context) {
           const { errorCode, span } = context;
           const info = errorCodeFixIdMap[errorCode];
           if (!info)
             return emptyArray;
-          const { descriptions, fixId: fixId51, fixAllDescriptions } = info;
+          const { descriptions, fixId: fixId52, fixAllDescriptions } = info;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start));
           return [
-            createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId51, fixAllDescriptions)
+            createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId52, fixAllDescriptions)
           ];
         },
         fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes19, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes20, (changes, diag2) => {
           const { code, start } = diag2;
           const info = errorCodeFixIdMap[code];
           if (!info || info.fixId !== context.fixId) {
@@ -141498,7 +141759,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts
-  function doChange5(changes, sourceFile, node, preferences) {
+  function doChange7(changes, sourceFile, node, preferences) {
     const quotePreference = getQuotePreference(sourceFile, preferences);
     const argumentsExpression = factory.createStringLiteral(node.name.text, quotePreference === 0 /* Single */);
     changes.replaceNode(
@@ -141510,32 +141771,32 @@ ${lanes.join("\n")}
   function getPropertyAccessExpression(sourceFile, pos) {
     return cast(getTokenAtPosition(sourceFile, pos).parent, isPropertyAccessExpression);
   }
-  var fixId17, errorCodes20;
+  var fixId18, errorCodes21;
   var init_fixNoPropertyAccessFromIndexSignature = __esm({
     "src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId17 = "fixNoPropertyAccessFromIndexSignature";
-      errorCodes20 = [
+      fixId18 = "fixNoPropertyAccessFromIndexSignature";
+      errorCodes21 = [
         Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes20,
-        fixIds: [fixId17],
+        errorCodes: errorCodes21,
+        fixIds: [fixId18],
         getCodeActions(context) {
           const { sourceFile, span, preferences } = context;
           const property = getPropertyAccessExpression(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange5(t, context.sourceFile, property, preferences));
-          return [createCodeFixAction(fixId17, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId17, Diagnostics.Use_element_access_for_all_undeclared_properties)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange7(t, context.sourceFile, property, preferences));
+          return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes20, (changes, diag2) => doChange5(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => doChange7(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
       });
     }
   });
 
   // src/services/codefixes/fixImplicitThis.ts
-  function doChange6(changes, sourceFile, pos, checker) {
+  function doChange8(changes, sourceFile, pos, checker) {
     const token = getTokenAtPosition(sourceFile, pos);
     if (!isThis(token))
       return void 0;
@@ -141576,27 +141837,27 @@ ${lanes.join("\n")}
       }
     }
   }
-  var fixId18, errorCodes21;
+  var fixId19, errorCodes22;
   var init_fixImplicitThis = __esm({
     "src/services/codefixes/fixImplicitThis.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId18 = "fixImplicitThis";
-      errorCodes21 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
+      fixId19 = "fixImplicitThis";
+      errorCodes22 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
       registerCodeFix({
-        errorCodes: errorCodes21,
+        errorCodes: errorCodes22,
         getCodeActions: function getCodeActionsToFixImplicitThis(context) {
           const { sourceFile, program, span } = context;
           let diagnostic;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
-            diagnostic = doChange6(t, sourceFile, span.start, program.getTypeChecker());
+            diagnostic = doChange8(t, sourceFile, span.start, program.getTypeChecker());
           });
-          return diagnostic ? [createCodeFixAction(fixId18, changes, diagnostic, fixId18, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray;
+          return diagnostic ? [createCodeFixAction(fixId19, changes, diagnostic, fixId19, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray;
         },
-        fixIds: [fixId18],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => {
-          doChange6(changes, diag2.file, diag2.start, context.program.getTypeChecker());
+        fixIds: [fixId19],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes22, (changes, diag2) => {
+          doChange8(changes, diag2.file, diag2.start, context.program.getTypeChecker());
         })
       });
     }
@@ -141639,7 +141900,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  function doChange7(changes, program, { exportName, node, moduleSourceFile }) {
+  function doChange9(changes, program, { exportName, node, moduleSourceFile }) {
     const exportDeclaration = tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly);
     if (exportDeclaration) {
       updateExport(changes, program, moduleSourceFile, exportDeclaration, [exportName]);
@@ -141721,32 +141982,32 @@ ${lanes.join("\n")}
     const variableStatement = isVariableDeclaration(declaration) ? tryCast(declaration.parent.parent, isVariableStatement) : void 0;
     return variableStatement && length(variableStatement.declarationList.declarations) === 1 ? variableStatement : declaration;
   }
-  var fixId19, errorCodes22;
+  var fixId20, errorCodes23;
   var init_fixImportNonExportedMember = __esm({
     "src/services/codefixes/fixImportNonExportedMember.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId19 = "fixImportNonExportedMember";
-      errorCodes22 = [
+      fixId20 = "fixImportNonExportedMember";
+      errorCodes23 = [
         Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes22,
-        fixIds: [fixId19],
+        errorCodes: errorCodes23,
+        fixIds: [fixId20],
         getCodeActions(context) {
           const { sourceFile, span, program } = context;
           const info = getInfo4(sourceFile, span.start, program);
           if (info === void 0)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange7(t, program, info));
-          return [createCodeFixAction(fixId19, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId19, Diagnostics.Export_all_referenced_locals)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange9(t, program, info));
+          return [createCodeFixAction(fixId20, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId20, Diagnostics.Export_all_referenced_locals)];
         },
         getAllCodeActions(context) {
           const { program } = context;
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
             const exports = /* @__PURE__ */ new Map();
-            eachDiagnostic(context, errorCodes22, (diag2) => {
+            eachDiagnostic(context, errorCodes23, (diag2) => {
               const info = getInfo4(diag2.file, diag2.start, program);
               if (info === void 0)
                 return void 0;
@@ -141791,7 +142052,7 @@ ${lanes.join("\n")}
     const token = getTokenAtPosition(sourceFile, pos);
     return findAncestor(token, (t) => t.kind === 199 /* NamedTupleMember */);
   }
-  function doChange8(changes, sourceFile, namedTupleMember) {
+  function doChange10(changes, sourceFile, namedTupleMember) {
     if (!namedTupleMember) {
       return;
     }
@@ -141818,26 +142079,26 @@ ${lanes.join("\n")}
     }
     changes.replaceNode(sourceFile, namedTupleMember, updated);
   }
-  var fixId20, errorCodes23;
+  var fixId21, errorCodes24;
   var init_fixIncorrectNamedTupleSyntax = __esm({
     "src/services/codefixes/fixIncorrectNamedTupleSyntax.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId20 = "fixIncorrectNamedTupleSyntax";
-      errorCodes23 = [
+      fixId21 = "fixIncorrectNamedTupleSyntax";
+      errorCodes24 = [
         Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code,
         Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes23,
+        errorCodes: errorCodes24,
         getCodeActions: function getCodeActionsToFixIncorrectNamedTupleSyntax(context) {
           const { sourceFile, span } = context;
           const namedTupleMember = getNamedTupleMember(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange8(t, sourceFile, namedTupleMember));
-          return [createCodeFixAction(fixId20, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId20, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange10(t, sourceFile, namedTupleMember));
+          return [createCodeFixAction(fixId21, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId21, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)];
         },
-        fixIds: [fixId20]
+        fixIds: [fixId21]
       });
     }
   });
@@ -141892,7 +142153,7 @@ ${lanes.join("\n")}
     }
     return suggestedSymbol === void 0 ? void 0 : { node, suggestedSymbol };
   }
-  function doChange9(changes, sourceFile, node, suggestedSymbol, target) {
+  function doChange11(changes, sourceFile, node, suggestedSymbol, target) {
     const suggestion = symbolName(suggestedSymbol);
     if (!isIdentifierText(suggestion, target) && isPropertyAccessExpression(node.parent)) {
       const valDecl = suggestedSymbol.valueDeclaration;
@@ -141926,14 +142187,14 @@ ${lanes.join("\n")}
       return void 0;
     return context.program.getSourceFile(resolvedModule.resolvedFileName);
   }
-  var fixId21, errorCodes24;
+  var fixId22, errorCodes25;
   var init_fixSpelling = __esm({
     "src/services/codefixes/fixSpelling.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId21 = "fixSpelling";
-      errorCodes24 = [
+      fixId22 = "fixSpelling";
+      errorCodes25 = [
         Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
         Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
@@ -141950,7 +142211,7 @@ ${lanes.join("\n")}
         Diagnostics.Type_0_is_not_assignable_to_type_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes24,
+        errorCodes: errorCodes25,
         getCodeActions(context) {
           const { sourceFile, errorCode } = context;
           const info = getInfo5(sourceFile, context.span.start, context, errorCode);
@@ -141958,15 +142219,15 @@ ${lanes.join("\n")}
             return void 0;
           const { node, suggestedSymbol } = info;
           const target = getEmitScriptTarget(context.host.getCompilationSettings());
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange9(t, sourceFile, node, suggestedSymbol, target));
-          return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId21, Diagnostics.Fix_all_detected_spelling_errors)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, sourceFile, node, suggestedSymbol, target));
+          return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId22, Diagnostics.Fix_all_detected_spelling_errors)];
         },
-        fixIds: [fixId21],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes24, (changes, diag2) => {
+        fixIds: [fixId22],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes25, (changes, diag2) => {
           const info = getInfo5(diag2.file, diag2.start, context, diag2.code);
           const target = getEmitScriptTarget(context.host.getCompilationSettings());
           if (info)
-            doChange9(changes, context.sourceFile, info.node, info.suggestedSymbol, target);
+            doChange11(changes, context.sourceFile, info.node, info.suggestedSymbol, target);
         })
       });
     }
@@ -142150,7 +142411,7 @@ ${lanes.join("\n")}
   }
   function getActionForfixAddReturnStatement(context, expression, statement) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addReturnStatement(t, context.sourceFile, expression, statement));
-    return createCodeFixAction(fixId22, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
+    return createCodeFixAction(fixId23, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
   }
   function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration, expression, commentSource) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => removeBlockBodyBrace(
@@ -142162,29 +142423,29 @@ ${lanes.join("\n")}
       /* withParen */
       false
     ));
-    return createCodeFixAction(fixId22, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues);
+    return createCodeFixAction(fixId23, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues);
   }
   function getActionForfixWrapTheBlockWithParen(context, declaration, expression) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => wrapBlockWithParen(t, context.sourceFile, declaration, expression));
-    return createCodeFixAction(fixId22, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses);
+    return createCodeFixAction(fixId23, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses);
   }
-  var fixId22, fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen, errorCodes25;
+  var fixId23, fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen, errorCodes26;
   var init_returnValueCorrect = __esm({
     "src/services/codefixes/returnValueCorrect.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId22 = "returnValueCorrect";
+      fixId23 = "returnValueCorrect";
       fixIdAddReturnStatement = "fixAddReturnStatement";
       fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody";
       fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen";
-      errorCodes25 = [
+      errorCodes26 = [
         Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code,
         Diagnostics.Type_0_is_not_assignable_to_type_1.code,
         Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes25,
+        errorCodes: errorCodes26,
         fixIds: [fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen],
         getCodeActions: function getCodeActionsToCorrectReturnValue(context) {
           const { program, sourceFile, span: { start }, errorCode } = context;
@@ -142200,7 +142461,7 @@ ${lanes.join("\n")}
             return [getActionForfixWrapTheBlockWithParen(context, info.declaration, info.expression)];
           }
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes25, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes26, (changes, diag2) => {
           const info = getInfo6(context.program.getTypeChecker(), diag2.file, diag2.start, diag2.code);
           if (!info)
             return void 0;
@@ -142766,7 +143027,7 @@ ${lanes.join("\n")}
     }
     return getSourceFileOfNode(node);
   }
-  var fixMissingMember, fixMissingProperties, fixMissingAttributes, fixMissingFunctionDeclaration, errorCodes26;
+  var fixMissingMember, fixMissingProperties, fixMissingAttributes, fixMissingFunctionDeclaration, errorCodes27;
   var init_fixAddMissingMember = __esm({
     "src/services/codefixes/fixAddMissingMember.ts"() {
       "use strict";
@@ -142776,7 +143037,7 @@ ${lanes.join("\n")}
       fixMissingProperties = "fixMissingProperties";
       fixMissingAttributes = "fixMissingAttributes";
       fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration";
-      errorCodes26 = [
+      errorCodes27 = [
         Diagnostics.Property_0_does_not_exist_on_type_1.code,
         Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
         Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2.code,
@@ -142786,7 +143047,7 @@ ${lanes.join("\n")}
         Diagnostics.Cannot_find_name_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes26,
+        errorCodes: errorCodes27,
         getCodeActions(context) {
           const typeChecker = context.program.getTypeChecker();
           const info = getInfo7(context.sourceFile, context.span.start, context.errorCode, typeChecker, context.program);
@@ -142813,21 +143074,21 @@ ${lanes.join("\n")}
         },
         fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes],
         getAllCodeActions: (context) => {
-          const { program, fixId: fixId51 } = context;
+          const { program, fixId: fixId52 } = context;
           const checker = program.getTypeChecker();
           const seen = /* @__PURE__ */ new Map();
           const typeDeclToMembers = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes26, (diag2) => {
+            eachDiagnostic(context, errorCodes27, (diag2) => {
               const info = getInfo7(diag2.file, diag2.start, diag2.code, checker, context.program);
               if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + info.token.text)) {
                 return;
               }
-              if (fixId51 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
+              if (fixId52 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
                 addFunctionDeclaration(changes, context, info);
-              } else if (fixId51 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
+              } else if (fixId52 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
                 addObjectLiteralProperties(changes, context, info);
-              } else if (fixId51 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
+              } else if (fixId52 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
                 addJsxAttributes(changes, context, info);
               } else {
                 if (info.kind === 1 /* Enum */) {
@@ -142883,23 +143144,23 @@ ${lanes.join("\n")}
     }
     return token;
   }
-  var fixId23, errorCodes27;
+  var fixId24, errorCodes28;
   var init_fixAddMissingNewOperator = __esm({
     "src/services/codefixes/fixAddMissingNewOperator.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId23 = "addMissingNewOperator";
-      errorCodes27 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
+      fixId24 = "addMissingNewOperator";
+      errorCodes28 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
       registerCodeFix({
-        errorCodes: errorCodes27,
+        errorCodes: errorCodes28,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingNewOperator(t, sourceFile, span));
-          return [createCodeFixAction(fixId23, changes, Diagnostics.Add_missing_new_operator_to_call, fixId23, Diagnostics.Add_missing_new_operator_to_all_calls)];
+          return [createCodeFixAction(fixId24, changes, Diagnostics.Add_missing_new_operator_to_call, fixId24, Diagnostics.Add_missing_new_operator_to_all_calls)];
         },
-        fixIds: [fixId23],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes27, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2))
+        fixIds: [fixId24],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes28, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2))
       });
     }
   });
@@ -142920,7 +143181,7 @@ ${lanes.join("\n")}
     var _a2;
     return diagCode === errorCodeCannotFindModule ? ts_JsTyping_exports.nodeCoreModules.has(packageName) ? "@types/node" : void 0 : ((_a2 = host.isKnownTypesPackageName) == null ? void 0 : _a2.call(host, packageName)) ? getTypesPackageName(packageName) : void 0;
   }
-  var fixName2, fixIdInstallTypesPackage, errorCodeCannotFindModule, errorCodes28;
+  var fixName2, fixIdInstallTypesPackage, errorCodeCannotFindModule, errorCodes29;
   var init_fixCannotFindModule = __esm({
     "src/services/codefixes/fixCannotFindModule.ts"() {
       "use strict";
@@ -142929,12 +143190,12 @@ ${lanes.join("\n")}
       fixName2 = "fixCannotFindModule";
       fixIdInstallTypesPackage = "installTypesPackage";
       errorCodeCannotFindModule = Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations.code;
-      errorCodes28 = [
+      errorCodes29 = [
         errorCodeCannotFindModule,
         Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes28,
+        errorCodes: errorCodes29,
         getCodeActions: function getCodeActionsToFixNotFoundModule(context) {
           const { host, sourceFile, span: { start } } = context;
           const packageName = tryGetImportedPackageName(sourceFile, start);
@@ -142953,7 +143214,7 @@ ${lanes.join("\n")}
         },
         fixIds: [fixIdInstallTypesPackage],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes28, (_changes, diag2, commands) => {
+          return codeFixAll(context, errorCodes29, (_changes, diag2, commands) => {
             const packageName = tryGetImportedPackageName(diag2.file, diag2.start);
             if (packageName === void 0)
               return void 0;
@@ -142992,28 +143253,28 @@ ${lanes.join("\n")}
     const flags = getSyntacticModifierFlags(first(symbol.getDeclarations()));
     return !(flags & 8 /* Private */) && !!(flags & 256 /* Abstract */);
   }
-  var errorCodes29, fixId24;
+  var errorCodes30, fixId25;
   var init_fixClassDoesntImplementInheritedAbstractMember = __esm({
     "src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes29 = [
+      errorCodes30 = [
         Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code,
         Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code
       ];
-      fixId24 = "fixClassDoesntImplementInheritedAbstractMember";
+      fixId25 = "fixClassDoesntImplementInheritedAbstractMember";
       registerCodeFix({
-        errorCodes: errorCodes29,
+        errorCodes: errorCodes30,
         getCodeActions: function getCodeActionsToFixClassNotImplementingInheritedMembers(context) {
           const { sourceFile, span } = context;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMembers(getClass2(sourceFile, span.start), sourceFile, context, t, context.preferences));
-          return changes.length === 0 ? void 0 : [createCodeFixAction(fixId24, changes, Diagnostics.Implement_inherited_abstract_class, fixId24, Diagnostics.Implement_all_inherited_abstract_classes)];
+          return changes.length === 0 ? void 0 : [createCodeFixAction(fixId25, changes, Diagnostics.Implement_inherited_abstract_class, fixId25, Diagnostics.Implement_all_inherited_abstract_classes)];
         },
-        fixIds: [fixId24],
+        fixIds: [fixId25],
         getAllCodeActions: function getAllCodeActionsToFixClassDoesntImplementInheritedAbstractMember(context) {
           const seenClassDeclarations = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes29, (changes, diag2) => {
+          return codeFixAll(context, errorCodes30, (changes, diag2) => {
             const classDeclaration = getClass2(diag2.file, diag2.start);
             if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
               addMissingMembers(classDeclaration, context.sourceFile, context, changes, context.preferences);
@@ -143025,7 +143286,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts
-  function doChange10(changes, sourceFile, constructor, superCall) {
+  function doChange12(changes, sourceFile, constructor, superCall) {
     changes.insertNodeAtConstructorStart(sourceFile, constructor, superCall);
     changes.delete(sourceFile, superCall);
   }
@@ -143040,36 +143301,36 @@ ${lanes.join("\n")}
   function findSuperCall(n) {
     return isExpressionStatement(n) && isSuperCall(n.expression) ? n : isFunctionLike(n) ? void 0 : forEachChild(n, findSuperCall);
   }
-  var fixId25, errorCodes30;
+  var fixId26, errorCodes31;
   var init_fixClassSuperMustPrecedeThisAccess = __esm({
     "src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId25 = "classSuperMustPrecedeThisAccess";
-      errorCodes30 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code];
+      fixId26 = "classSuperMustPrecedeThisAccess";
+      errorCodes31 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code];
       registerCodeFix({
-        errorCodes: errorCodes30,
+        errorCodes: errorCodes31,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const nodes = getNodes(sourceFile, span.start);
           if (!nodes)
             return void 0;
           const { constructor, superCall } = nodes;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange10(t, sourceFile, constructor, superCall));
-          return [createCodeFixAction(fixId25, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId25, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange12(t, sourceFile, constructor, superCall));
+          return [createCodeFixAction(fixId26, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId26, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)];
         },
-        fixIds: [fixId25],
+        fixIds: [fixId26],
         getAllCodeActions(context) {
           const { sourceFile } = context;
           const seenClasses = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes30, (changes, diag2) => {
+          return codeFixAll(context, errorCodes31, (changes, diag2) => {
             const nodes = getNodes(diag2.file, diag2.start);
             if (!nodes)
               return;
             const { constructor, superCall } = nodes;
             if (addToSeen(seenClasses, getNodeId(constructor.parent))) {
-              doChange10(changes, sourceFile, constructor, superCall);
+              doChange12(changes, sourceFile, constructor, superCall);
             }
           });
         }
@@ -143083,7 +143344,7 @@ ${lanes.join("\n")}
     Debug.assert(isConstructorDeclaration(token.parent), "token should be at the constructor declaration");
     return token.parent;
   }
-  function doChange11(changes, sourceFile, ctr) {
+  function doChange13(changes, sourceFile, ctr) {
     const superCall = factory.createExpressionStatement(factory.createCallExpression(
       factory.createSuper(),
       /*typeArguments*/
@@ -143093,42 +143354,42 @@ ${lanes.join("\n")}
     ));
     changes.insertNodeAtConstructorStart(sourceFile, ctr, superCall);
   }
-  var fixId26, errorCodes31;
+  var fixId27, errorCodes32;
   var init_fixConstructorForDerivedNeedSuperCall = __esm({
     "src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId26 = "constructorForDerivedNeedSuperCall";
-      errorCodes31 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code];
+      fixId27 = "constructorForDerivedNeedSuperCall";
+      errorCodes32 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code];
       registerCodeFix({
-        errorCodes: errorCodes31,
+        errorCodes: errorCodes32,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const ctr = getNode(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, sourceFile, ctr));
-          return [createCodeFixAction(fixId26, changes, Diagnostics.Add_missing_super_call, fixId26, Diagnostics.Add_all_missing_super_calls)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange13(t, sourceFile, ctr));
+          return [createCodeFixAction(fixId27, changes, Diagnostics.Add_missing_super_call, fixId27, Diagnostics.Add_all_missing_super_calls)];
         },
-        fixIds: [fixId26],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes31, (changes, diag2) => doChange11(changes, context.sourceFile, getNode(diag2.file, diag2.start)))
+        fixIds: [fixId27],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes32, (changes, diag2) => doChange13(changes, context.sourceFile, getNode(diag2.file, diag2.start)))
       });
     }
   });
 
   // src/services/codefixes/fixEnableJsxFlag.ts
-  function doChange12(changeTracker, configFile) {
+  function doChange14(changeTracker, configFile) {
     setJsonCompilerOptionValue(changeTracker, configFile, "jsx", factory.createStringLiteral("react"));
   }
-  var fixID, errorCodes32;
+  var fixID, errorCodes33;
   var init_fixEnableJsxFlag = __esm({
     "src/services/codefixes/fixEnableJsxFlag.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixID = "fixEnableJsxFlag";
-      errorCodes32 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code];
+      errorCodes33 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code];
       registerCodeFix({
-        errorCodes: errorCodes32,
+        errorCodes: errorCodes33,
         getCodeActions: function getCodeActionsToFixEnableJsxFlag(context) {
           const { configFile } = context.program.getCompilerOptions();
           if (configFile === void 0) {
@@ -143136,19 +143397,19 @@ ${lanes.join("\n")}
           }
           const changes = ts_textChanges_exports.ChangeTracker.with(
             context,
-            (changeTracker) => doChange12(changeTracker, configFile)
+            (changeTracker) => doChange14(changeTracker, configFile)
           );
           return [
             createCodeFixActionWithoutFixAll(fixID, changes, Diagnostics.Enable_the_jsx_flag_in_your_configuration_file)
           ];
         },
         fixIds: [fixID],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes32, (changes) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes33, (changes) => {
           const { configFile } = context.program.getCompilerOptions();
           if (configFile === void 0) {
             return void 0;
           }
-          doChange12(changes, configFile);
+          doChange14(changes, configFile);
         })
       });
     }
@@ -143170,7 +143431,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  function doChange13(changes, sourceFile, arg, expression) {
+  function doChange15(changes, sourceFile, arg, expression) {
     const callExpression = factory.createCallExpression(
       factory.createPropertyAccessExpression(factory.createIdentifier("Number"), factory.createIdentifier("isNaN")),
       /*typeArguments*/
@@ -143188,33 +143449,33 @@ ${lanes.join("\n")}
     const [_, suggestion] = flattenDiagnosticMessageText(messageText, "\n", 0).match(/\'(.*)\'/) || [];
     return suggestion;
   }
-  var fixId27, errorCodes33;
+  var fixId28, errorCodes34;
   var init_fixNaNEquality = __esm({
     "src/services/codefixes/fixNaNEquality.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId27 = "fixNaNEquality";
-      errorCodes33 = [
+      fixId28 = "fixNaNEquality";
+      errorCodes34 = [
         Diagnostics.This_condition_will_always_return_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes33,
+        errorCodes: errorCodes34,
         getCodeActions(context) {
           const { sourceFile, span, program } = context;
           const info = getInfo8(program, sourceFile, span);
           if (info === void 0)
             return;
           const { suggestion, expression, arg } = info;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange13(t, sourceFile, arg, expression));
-          return [createCodeFixAction(fixId27, changes, [Diagnostics.Use_0, suggestion], fixId27, Diagnostics.Use_Number_isNaN_in_all_conditions)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange15(t, sourceFile, arg, expression));
+          return [createCodeFixAction(fixId28, changes, [Diagnostics.Use_0, suggestion], fixId28, Diagnostics.Use_Number_isNaN_in_all_conditions)];
         },
-        fixIds: [fixId27],
+        fixIds: [fixId28],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes33, (changes, diag2) => {
+          return codeFixAll(context, errorCodes34, (changes, diag2) => {
             const info = getInfo8(context.program, diag2.file, createTextSpan(diag2.start, diag2.length));
             if (info) {
-              doChange13(changes, diag2.file, info.arg, info.expression);
+              doChange15(changes, diag2.file, info.arg, info.expression);
             }
           });
         }
@@ -143270,32 +143531,32 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixPropertyAssignment.ts
-  function doChange14(changes, sourceFile, node) {
+  function doChange16(changes, sourceFile, node) {
     changes.replaceNode(sourceFile, node, factory.createPropertyAssignment(node.name, node.objectAssignmentInitializer));
   }
   function getProperty2(sourceFile, pos) {
     return cast(getTokenAtPosition(sourceFile, pos).parent, isShorthandPropertyAssignment);
   }
-  var fixId28, errorCodes34;
+  var fixId29, errorCodes35;
   var init_fixPropertyAssignment = __esm({
     "src/services/codefixes/fixPropertyAssignment.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId28 = "fixPropertyAssignment";
-      errorCodes34 = [
+      fixId29 = "fixPropertyAssignment";
+      errorCodes35 = [
         Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes34,
-        fixIds: [fixId28],
+        errorCodes: errorCodes35,
+        fixIds: [fixId29],
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const property = getProperty2(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property));
-          return [createCodeFixAction(fixId28, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId28, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(t, context.sourceFile, property));
+          return [createCodeFixAction(fixId29, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId29, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes34, (changes, diag2) => doChange14(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => doChange16(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
       });
     }
   });
@@ -143321,16 +143582,16 @@ ${lanes.join("\n")}
       changes.deleteRange(sourceFile, { pos: implementsToken.getStart(), end });
     }
   }
-  var fixId29, errorCodes35;
+  var fixId30, errorCodes36;
   var init_fixExtendsInterfaceBecomesImplements = __esm({
     "src/services/codefixes/fixExtendsInterfaceBecomesImplements.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId29 = "extendsInterfaceBecomesImplements";
-      errorCodes35 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code];
+      fixId30 = "extendsInterfaceBecomesImplements";
+      errorCodes36 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code];
       registerCodeFix({
-        errorCodes: errorCodes35,
+        errorCodes: errorCodes36,
         getCodeActions(context) {
           const { sourceFile } = context;
           const nodes = getNodes2(sourceFile, context.span.start);
@@ -143338,10 +143599,10 @@ ${lanes.join("\n")}
             return void 0;
           const { extendsToken, heritageClauses } = nodes;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChanges2(t, sourceFile, extendsToken, heritageClauses));
-          return [createCodeFixAction(fixId29, changes, Diagnostics.Change_extends_to_implements, fixId29, Diagnostics.Change_all_extended_interfaces_to_implements)];
+          return [createCodeFixAction(fixId30, changes, Diagnostics.Change_extends_to_implements, fixId30, Diagnostics.Change_all_extended_interfaces_to_implements)];
         },
-        fixIds: [fixId29],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => {
+        fixIds: [fixId30],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes36, (changes, diag2) => {
           const nodes = getNodes2(diag2.file, diag2.start);
           if (nodes)
             doChanges2(changes, diag2.file, nodes.extendsToken, nodes.heritageClauses);
@@ -143357,39 +143618,39 @@ ${lanes.join("\n")}
       return { node, className: diagCode === didYouMeanStaticMemberCode ? getContainingClass(node).name.text : void 0 };
     }
   }
-  function doChange15(changes, sourceFile, { node, className }) {
+  function doChange17(changes, sourceFile, { node, className }) {
     suppressLeadingAndTrailingTrivia(node);
     changes.replaceNode(sourceFile, node, factory.createPropertyAccessExpression(className ? factory.createIdentifier(className) : factory.createThis(), node));
   }
-  var fixId30, didYouMeanStaticMemberCode, errorCodes36;
+  var fixId31, didYouMeanStaticMemberCode, errorCodes37;
   var init_fixForgottenThisPropertyAccess = __esm({
     "src/services/codefixes/fixForgottenThisPropertyAccess.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId30 = "forgottenThisPropertyAccess";
+      fixId31 = "forgottenThisPropertyAccess";
       didYouMeanStaticMemberCode = Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code;
-      errorCodes36 = [
+      errorCodes37 = [
         Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
         Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code,
         didYouMeanStaticMemberCode
       ];
       registerCodeFix({
-        errorCodes: errorCodes36,
+        errorCodes: errorCodes37,
         getCodeActions(context) {
           const { sourceFile } = context;
           const info = getInfo9(sourceFile, context.span.start, context.errorCode);
           if (!info) {
             return void 0;
           }
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange15(t, sourceFile, info));
-          return [createCodeFixAction(fixId30, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId30, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, sourceFile, info));
+          return [createCodeFixAction(fixId31, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId31, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)];
         },
-        fixIds: [fixId30],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes36, (changes, diag2) => {
+        fixIds: [fixId31],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes37, (changes, diag2) => {
           const info = getInfo9(diag2.file, diag2.start, diag2.code);
           if (info)
-            doChange15(changes, context.sourceFile, info);
+            doChange17(changes, context.sourceFile, info);
         })
       });
     }
@@ -143399,7 +143660,7 @@ ${lanes.join("\n")}
   function isValidCharacter(character) {
     return hasProperty(htmlEntity, character);
   }
-  function doChange16(changes, preferences, sourceFile, start, useHtmlEntity) {
+  function doChange18(changes, preferences, sourceFile, start, useHtmlEntity) {
     const character = sourceFile.getText()[start];
     if (!isValidCharacter(character)) {
       return;
@@ -143407,7 +143668,7 @@ ${lanes.join("\n")}
     const replacement = useHtmlEntity ? htmlEntity[character] : `{${quote(sourceFile, preferences, character)}}`;
     changes.replaceRangeWithText(sourceFile, { pos: start, end: start + 1 }, replacement);
   }
-  var fixIdExpression, fixIdHtmlEntity, errorCodes37, htmlEntity;
+  var fixIdExpression, fixIdHtmlEntity, errorCodes38, htmlEntity;
   var init_fixInvalidJsxCharacters = __esm({
     "src/services/codefixes/fixInvalidJsxCharacters.ts"() {
       "use strict";
@@ -143415,16 +143676,16 @@ ${lanes.join("\n")}
       init_ts_codefix();
       fixIdExpression = "fixInvalidJsxCharacters_expression";
       fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity";
-      errorCodes37 = [
+      errorCodes38 = [
         Diagnostics.Unexpected_token_Did_you_mean_or_gt.code,
         Diagnostics.Unexpected_token_Did_you_mean_or_rbrace.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes37,
+        errorCodes: errorCodes38,
         fixIds: [fixIdExpression, fixIdHtmlEntity],
         getCodeActions(context) {
           const { sourceFile, preferences, span } = context;
-          const changeToExpression = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(
+          const changeToExpression = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(
             t,
             preferences,
             sourceFile,
@@ -143432,7 +143693,7 @@ ${lanes.join("\n")}
             /* useHtmlEntity */
             false
           ));
-          const changeToHtmlEntity = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(
+          const changeToHtmlEntity = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(
             t,
             preferences,
             sourceFile,
@@ -143446,7 +143707,7 @@ ${lanes.join("\n")}
           ];
         },
         getAllCodeActions(context) {
-          return codeFixAll(context, errorCodes37, (changes, diagnostic) => doChange16(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity));
+          return codeFixAll(context, errorCodes38, (changes, diagnostic) => doChange18(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity));
         }
       });
       htmlEntity = {
@@ -143505,7 +143766,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  var deleteUnmatchedParameter, renameUnmatchedParameter, errorCodes38;
+  var deleteUnmatchedParameter, renameUnmatchedParameter, errorCodes39;
   var init_fixUnmatchedParameter = __esm({
     "src/services/codefixes/fixUnmatchedParameter.ts"() {
       "use strict";
@@ -143513,12 +143774,12 @@ ${lanes.join("\n")}
       init_ts_codefix();
       deleteUnmatchedParameter = "deleteUnmatchedParameter";
       renameUnmatchedParameter = "renameUnmatchedParameter";
-      errorCodes38 = [
+      errorCodes39 = [
         Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code
       ];
       registerCodeFix({
         fixIds: [deleteUnmatchedParameter, renameUnmatchedParameter],
-        errorCodes: errorCodes38,
+        errorCodes: errorCodes39,
         getCodeActions: function getCodeActionsToFixUnmatchedParameter(context) {
           const { sourceFile, span } = context;
           const actions2 = [];
@@ -143533,7 +143794,7 @@ ${lanes.join("\n")}
         getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) {
           const tagsToSignature = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes38, ({ file, start }) => {
+            eachDiagnostic(context, errorCodes39, ({ file, start }) => {
               const info = getInfo10(file, start);
               if (info) {
                 tagsToSignature.set(info.signature, append(tagsToSignature.get(info.signature), info.jsDocParameterTag));
@@ -143582,16 +143843,16 @@ ${lanes.join("\n")}
   function doNamespaceImportChange(changes, sourceFile, importDeclaration, program) {
     ts_refactor_exports.doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, importDeclaration.parent);
   }
-  var fixId31, errorCodes39;
+  var fixId32, errorCodes40;
   var init_fixUnreferenceableDecoratorMetadata = __esm({
     "src/services/codefixes/fixUnreferenceableDecoratorMetadata.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId31 = "fixUnreferenceableDecoratorMetadata";
-      errorCodes39 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code];
+      fixId32 = "fixUnreferenceableDecoratorMetadata";
+      errorCodes40 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code];
       registerCodeFix({
-        errorCodes: errorCodes39,
+        errorCodes: errorCodes40,
         getCodeActions: (context) => {
           const importDeclaration = getImportDeclaration(context.sourceFile, context.program, context.span.start);
           if (!importDeclaration)
@@ -143600,14 +143861,14 @@ ${lanes.join("\n")}
           const typeOnlyChanges = ts_textChanges_exports.ChangeTracker.with(context, (t) => doTypeOnlyImportChange(t, context.sourceFile, importDeclaration, context.program));
           let actions2;
           if (namespaceChanges.length) {
-            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId31, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import));
+            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import));
           }
           if (typeOnlyChanges.length) {
-            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId31, typeOnlyChanges, Diagnostics.Convert_to_type_only_import));
+            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, typeOnlyChanges, Diagnostics.Convert_to_type_only_import));
           }
           return actions2;
         },
-        fixIds: [fixId31]
+        fixIds: [fixId32]
       });
     }
   });
@@ -143760,7 +144021,7 @@ ${lanes.join("\n")}
   function mayDeleteExpression(node) {
     return (isBinaryExpression(node.parent) && node.parent.left === node || (isPostfixUnaryExpression(node.parent) || isPrefixUnaryExpression(node.parent)) && node.parent.operand === node) && isExpressionStatement(node.parent.parent);
   }
-  var fixName3, fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer, errorCodes40;
+  var fixName3, fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer, errorCodes41;
   var init_fixUnusedIdentifier = __esm({
     "src/services/codefixes/fixUnusedIdentifier.ts"() {
       "use strict";
@@ -143771,7 +144032,7 @@ ${lanes.join("\n")}
       fixIdDelete = "unusedIdentifier_delete";
       fixIdDeleteImports = "unusedIdentifier_deleteImports";
       fixIdInfer = "unusedIdentifier_infer";
-      errorCodes40 = [
+      errorCodes41 = [
         Diagnostics._0_is_declared_but_its_value_is_never_read.code,
         Diagnostics._0_is_declared_but_never_used.code,
         Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code,
@@ -143781,7 +144042,7 @@ ${lanes.join("\n")}
         Diagnostics.All_type_parameters_are_unused.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes40,
+        errorCodes: errorCodes41,
         getCodeActions(context) {
           const { errorCode, sourceFile, program, cancellationToken } = context;
           const checker = program.getTypeChecker();
@@ -143867,7 +144128,7 @@ ${lanes.join("\n")}
           const { sourceFile, program, cancellationToken } = context;
           const checker = program.getTypeChecker();
           const sourceFiles = program.getSourceFiles();
-          return codeFixAll(context, errorCodes40, (changes, diag2) => {
+          return codeFixAll(context, errorCodes41, (changes, diag2) => {
             const token = getTokenAtPosition(sourceFile, diag2.start);
             switch (context.fixId) {
               case fixIdPrefix:
@@ -143939,7 +144200,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixUnreachableCode.ts
-  function doChange17(changes, sourceFile, start, length2, errorCode) {
+  function doChange19(changes, sourceFile, start, length2, errorCode) {
     const token = getTokenAtPosition(sourceFile, start);
     const statement = findAncestor(token, isStatement);
     if (statement.getStart(sourceFile) !== token.getStart(sourceFile)) {
@@ -143987,31 +144248,31 @@ ${lanes.join("\n")}
     }
     return last2;
   }
-  var fixId32, errorCodes41;
+  var fixId33, errorCodes42;
   var init_fixUnreachableCode = __esm({
     "src/services/codefixes/fixUnreachableCode.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId32 = "fixUnreachableCode";
-      errorCodes41 = [Diagnostics.Unreachable_code_detected.code];
+      fixId33 = "fixUnreachableCode";
+      errorCodes42 = [Diagnostics.Unreachable_code_detected.code];
       registerCodeFix({
-        errorCodes: errorCodes41,
+        errorCodes: errorCodes42,
         getCodeActions(context) {
           const syntacticDiagnostics = context.program.getSyntacticDiagnostics(context.sourceFile, context.cancellationToken);
           if (syntacticDiagnostics.length)
             return;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, context.sourceFile, context.span.start, context.span.length, context.errorCode));
-          return [createCodeFixAction(fixId32, changes, Diagnostics.Remove_unreachable_code, fixId32, Diagnostics.Remove_all_unreachable_code)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange19(t, context.sourceFile, context.span.start, context.span.length, context.errorCode));
+          return [createCodeFixAction(fixId33, changes, Diagnostics.Remove_unreachable_code, fixId33, Diagnostics.Remove_all_unreachable_code)];
         },
-        fixIds: [fixId32],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes41, (changes, diag2) => doChange17(changes, diag2.file, diag2.start, diag2.length, diag2.code))
+        fixIds: [fixId33],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes42, (changes, diag2) => doChange19(changes, diag2.file, diag2.start, diag2.length, diag2.code))
       });
     }
   });
 
   // src/services/codefixes/fixUnusedLabel.ts
-  function doChange18(changes, sourceFile, start) {
+  function doChange20(changes, sourceFile, start) {
     const token = getTokenAtPosition(sourceFile, start);
     const labeledStatement = cast(token.parent, isLabeledStatement);
     const pos = token.getStart(sourceFile);
@@ -144024,28 +144285,28 @@ ${lanes.join("\n")}
     );
     changes.deleteRange(sourceFile, { pos, end });
   }
-  var fixId33, errorCodes42;
+  var fixId34, errorCodes43;
   var init_fixUnusedLabel = __esm({
     "src/services/codefixes/fixUnusedLabel.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId33 = "fixUnusedLabel";
-      errorCodes42 = [Diagnostics.Unused_label.code];
+      fixId34 = "fixUnusedLabel";
+      errorCodes43 = [Diagnostics.Unused_label.code];
       registerCodeFix({
-        errorCodes: errorCodes42,
+        errorCodes: errorCodes43,
         getCodeActions(context) {
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(t, context.sourceFile, context.span.start));
-          return [createCodeFixAction(fixId33, changes, Diagnostics.Remove_unused_label, fixId33, Diagnostics.Remove_all_unused_labels)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange20(t, context.sourceFile, context.span.start));
+          return [createCodeFixAction(fixId34, changes, Diagnostics.Remove_unused_label, fixId34, Diagnostics.Remove_all_unused_labels)];
         },
-        fixIds: [fixId33],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes42, (changes, diag2) => doChange18(changes, diag2.file, diag2.start))
+        fixIds: [fixId34],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes43, (changes, diag2) => doChange20(changes, diag2.file, diag2.start))
       });
     }
   });
 
   // src/services/codefixes/fixJSDocTypes.ts
-  function doChange19(changes, sourceFile, oldTypeNode, newType, checker) {
+  function doChange21(changes, sourceFile, oldTypeNode, newType, checker) {
     changes.replaceNode(sourceFile, oldTypeNode, checker.typeToTypeNode(
       newType,
       /*enclosingDeclaration*/
@@ -144094,7 +144355,7 @@ ${lanes.join("\n")}
     }
     return checker.getTypeFromTypeNode(node);
   }
-  var fixIdPlain, fixIdNullable, errorCodes43;
+  var fixIdPlain, fixIdNullable, errorCodes44;
   var init_fixJSDocTypes = __esm({
     "src/services/codefixes/fixJSDocTypes.ts"() {
       "use strict";
@@ -144102,13 +144363,13 @@ ${lanes.join("\n")}
       init_ts_codefix();
       fixIdPlain = "fixJSDocTypes_plain";
       fixIdNullable = "fixJSDocTypes_nullable";
-      errorCodes43 = [
+      errorCodes44 = [
         Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments.code,
         Diagnostics._0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code,
         Diagnostics._0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes43,
+        errorCodes: errorCodes44,
         getCodeActions(context) {
           const { sourceFile } = context;
           const checker = context.program.getTypeChecker();
@@ -144122,22 +144383,22 @@ ${lanes.join("\n")}
             actions2.push(fix(type, fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types));
           }
           return actions2;
-          function fix(type2, fixId51, fixAllDescription) {
-            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange19(t, sourceFile, typeNode, type2, checker));
-            return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId51, fixAllDescription);
+          function fix(type2, fixId52, fixAllDescription) {
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange21(t, sourceFile, typeNode, type2, checker));
+            return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId52, fixAllDescription);
           }
         },
         fixIds: [fixIdPlain, fixIdNullable],
         getAllCodeActions(context) {
-          const { fixId: fixId51, program, sourceFile } = context;
+          const { fixId: fixId52, program, sourceFile } = context;
           const checker = program.getTypeChecker();
-          return codeFixAll(context, errorCodes43, (changes, err) => {
+          return codeFixAll(context, errorCodes44, (changes, err) => {
             const info = getInfo11(err.file, err.start, checker);
             if (!info)
               return;
             const { typeNode, type } = info;
-            const fixedType = typeNode.kind === 317 /* JSDocNullableType */ && fixId51 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
-            doChange19(changes, sourceFile, typeNode, fixedType, checker);
+            const fixedType = typeNode.kind === 317 /* JSDocNullableType */ && fixId52 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
+            doChange21(changes, sourceFile, typeNode, fixedType, checker);
           });
         }
       });
@@ -144145,7 +144406,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixMissingCallParentheses.ts
-  function doChange20(changes, sourceFile, name) {
+  function doChange22(changes, sourceFile, name) {
     changes.replaceNodeWithText(sourceFile, name, `${name.text}()`);
   }
   function getCallName(sourceFile, start) {
@@ -144162,31 +144423,31 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  var fixId34, errorCodes44;
+  var fixId35, errorCodes45;
   var init_fixMissingCallParentheses = __esm({
     "src/services/codefixes/fixMissingCallParentheses.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId34 = "fixMissingCallParentheses";
-      errorCodes44 = [
+      fixId35 = "fixMissingCallParentheses";
+      errorCodes45 = [
         Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes44,
-        fixIds: [fixId34],
+        errorCodes: errorCodes45,
+        fixIds: [fixId35],
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const callName = getCallName(sourceFile, span.start);
           if (!callName)
             return;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange20(t, context.sourceFile, callName));
-          return [createCodeFixAction(fixId34, changes, Diagnostics.Add_missing_call_parentheses, fixId34, Diagnostics.Add_all_missing_call_parentheses)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange22(t, context.sourceFile, callName));
+          return [createCodeFixAction(fixId35, changes, Diagnostics.Add_missing_call_parentheses, fixId35, Diagnostics.Add_all_missing_call_parentheses)];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes44, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes45, (changes, diag2) => {
           const callName = getCallName(diag2.file, diag2.start);
           if (callName)
-            doChange20(changes, diag2.file, callName);
+            doChange22(changes, diag2.file, callName);
         })
       });
     }
@@ -144228,7 +144489,7 @@ ${lanes.join("\n")}
       returnType: getReturnType(containingFunction)
     };
   }
-  function doChange21(changes, sourceFile, { insertBefore, returnType }) {
+  function doChange23(changes, sourceFile, { insertBefore, returnType }) {
     if (returnType) {
       const entityName = getEntityNameFromTypeNode(returnType);
       if (!entityName || entityName.kind !== 79 /* Identifier */ || entityName.text !== "Promise") {
@@ -144237,36 +144498,36 @@ ${lanes.join("\n")}
     }
     changes.insertModifierBefore(sourceFile, 132 /* AsyncKeyword */, insertBefore);
   }
-  var fixId35, errorCodes45;
+  var fixId36, errorCodes46;
   var init_fixAwaitInSyncFunction = __esm({
     "src/services/codefixes/fixAwaitInSyncFunction.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId35 = "fixAwaitInSyncFunction";
-      errorCodes45 = [
+      fixId36 = "fixAwaitInSyncFunction";
+      errorCodes46 = [
         Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
         Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes45,
+        errorCodes: errorCodes46,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const nodes = getNodes3(sourceFile, span.start);
           if (!nodes)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange21(t, sourceFile, nodes));
-          return [createCodeFixAction(fixId35, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId35, Diagnostics.Add_all_missing_async_modifiers)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, sourceFile, nodes));
+          return [createCodeFixAction(fixId36, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId36, Diagnostics.Add_all_missing_async_modifiers)];
         },
-        fixIds: [fixId35],
+        fixIds: [fixId36],
         getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) {
           const seen = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes45, (changes, diag2) => {
+          return codeFixAll(context, errorCodes46, (changes, diag2) => {
             const nodes = getNodes3(diag2.file, diag2.start);
             if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore)))
               return;
-            doChange21(changes, context.sourceFile, nodes);
+            doChange23(changes, context.sourceFile, nodes);
           });
         }
       });
@@ -144274,7 +144535,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixPropertyOverrideAccessor.ts
-  function doChange22(file, start, length2, code, context) {
+  function doChange24(file, start, length2, code, context) {
     let startPosition;
     let endPosition;
     if (code === Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code) {
@@ -144301,28 +144562,28 @@ ${lanes.join("\n")}
     }
     return generateAccessorFromProperty(file, context.program, startPosition, endPosition, context, Diagnostics.Generate_get_and_set_accessors.message);
   }
-  var errorCodes46, fixId36;
+  var errorCodes47, fixId37;
   var init_fixPropertyOverrideAccessor = __esm({
     "src/services/codefixes/fixPropertyOverrideAccessor.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes46 = [
+      errorCodes47 = [
         Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code,
         Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code
       ];
-      fixId36 = "fixPropertyOverrideAccessor";
+      fixId37 = "fixPropertyOverrideAccessor";
       registerCodeFix({
-        errorCodes: errorCodes46,
+        errorCodes: errorCodes47,
         getCodeActions(context) {
-          const edits = doChange22(context.sourceFile, context.span.start, context.span.length, context.errorCode, context);
+          const edits = doChange24(context.sourceFile, context.span.start, context.span.length, context.errorCode, context);
           if (edits) {
-            return [createCodeFixAction(fixId36, edits, Diagnostics.Generate_get_and_set_accessors, fixId36, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
+            return [createCodeFixAction(fixId37, edits, Diagnostics.Generate_get_and_set_accessors, fixId37, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
           }
         },
-        fixIds: [fixId36],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes46, (changes, diag2) => {
-          const edits = doChange22(diag2.file, diag2.start, diag2.length, diag2.code, context);
+        fixIds: [fixId37],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes47, (changes, diag2) => {
+          const edits = doChange24(diag2.file, diag2.start, diag2.length, diag2.code, context);
           if (edits) {
             for (const edit of edits) {
               changes.pushRaw(context.sourceFile, edit);
@@ -144369,7 +144630,7 @@ ${lanes.join("\n")}
     }
     return errorCode;
   }
-  function doChange23(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) {
+  function doChange25(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) {
     if (!isParameterPropertyModifier(token.kind) && token.kind !== 79 /* Identifier */ && token.kind !== 25 /* DotDotDotToken */ && token.kind !== 108 /* ThisKeyword */) {
       return void 0;
     }
@@ -145263,14 +145524,14 @@ ${lanes.join("\n")}
       }
     }
   }
-  var fixId37, errorCodes47;
+  var fixId38, errorCodes48;
   var init_inferFromUsage = __esm({
     "src/services/codefixes/inferFromUsage.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId37 = "inferFromUsage";
-      errorCodes47 = [
+      fixId38 = "inferFromUsage";
+      errorCodes48 = [
         // Variable declarations
         Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code,
         // Variable uses
@@ -145304,13 +145565,13 @@ ${lanes.join("\n")}
         Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes47,
+        errorCodes: errorCodes48,
         getCodeActions(context) {
           const { sourceFile, program, span: { start }, errorCode, cancellationToken, host, preferences } = context;
           const token = getTokenAtPosition(sourceFile, start);
           let declaration;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
-            declaration = doChange23(
+            declaration = doChange25(
               changes2,
               sourceFile,
               token,
@@ -145324,14 +145585,14 @@ ${lanes.join("\n")}
             );
           });
           const name = declaration && getNameOfDeclaration(declaration);
-          return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId37, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId37, Diagnostics.Infer_all_types_from_usage)];
+          return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId38, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId38, Diagnostics.Infer_all_types_from_usage)];
         },
-        fixIds: [fixId37],
+        fixIds: [fixId38],
         getAllCodeActions(context) {
           const { sourceFile, program, cancellationToken, host, preferences } = context;
           const markSeen = nodeSeenTracker();
-          return codeFixAll(context, errorCodes47, (changes, err) => {
-            doChange23(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
+          return codeFixAll(context, errorCodes48, (changes, err) => {
+            doChange25(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
           });
         }
       });
@@ -145362,22 +145623,22 @@ ${lanes.join("\n")}
       return { returnTypeNode, returnType, promisedTypeNode, promisedType };
     }
   }
-  function doChange24(changes, sourceFile, returnTypeNode, promisedTypeNode) {
+  function doChange26(changes, sourceFile, returnTypeNode, promisedTypeNode) {
     changes.replaceNode(sourceFile, returnTypeNode, factory.createTypeReferenceNode("Promise", [promisedTypeNode]));
   }
-  var fixId38, errorCodes48;
+  var fixId39, errorCodes49;
   var init_fixReturnTypeInAsyncFunction = __esm({
     "src/services/codefixes/fixReturnTypeInAsyncFunction.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId38 = "fixReturnTypeInAsyncFunction";
-      errorCodes48 = [
+      fixId39 = "fixReturnTypeInAsyncFunction";
+      errorCodes49 = [
         Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes48,
-        fixIds: [fixId38],
+        errorCodes: errorCodes49,
+        fixIds: [fixId39],
         getCodeActions: function getCodeActionsToFixReturnTypeInAsyncFunction(context) {
           const { sourceFile, program, span } = context;
           const checker = program.getTypeChecker();
@@ -145386,23 +145647,23 @@ ${lanes.join("\n")}
             return void 0;
           }
           const { returnTypeNode, returnType, promisedTypeNode, promisedType } = info;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange24(t, sourceFile, returnTypeNode, promisedTypeNode));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange26(t, sourceFile, returnTypeNode, promisedTypeNode));
           return [createCodeFixAction(
-            fixId38,
+            fixId39,
             changes,
             [
               Diagnostics.Replace_0_with_Promise_1,
               checker.typeToString(returnType),
               checker.typeToString(promisedType)
             ],
-            fixId38,
+            fixId39,
             Diagnostics.Fix_all_incorrect_return_type_of_an_async_functions
           )];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes48, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes49, (changes, diag2) => {
           const info = getInfo12(diag2.file, context.program.getTypeChecker(), diag2.start);
           if (info) {
-            doChange24(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode);
+            doChange26(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode);
           }
         })
       });
@@ -145416,20 +145677,20 @@ ${lanes.join("\n")}
       changes.insertCommentBeforeLine(sourceFile, lineNumber, position, " @ts-ignore");
     }
   }
-  var fixName4, fixId39, errorCodes49;
+  var fixName4, fixId40, errorCodes50;
   var init_disableJsDiagnostics = __esm({
     "src/services/codefixes/disableJsDiagnostics.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixName4 = "disableJsDiagnostics";
-      fixId39 = "disableJsDiagnostics";
-      errorCodes49 = mapDefined(Object.keys(Diagnostics), (key) => {
+      fixId40 = "disableJsDiagnostics";
+      errorCodes50 = mapDefined(Object.keys(Diagnostics), (key) => {
         const diag2 = Diagnostics[key];
         return diag2.category === 1 /* Error */ ? diag2.code : void 0;
       });
       registerCodeFix({
-        errorCodes: errorCodes49,
+        errorCodes: errorCodes50,
         getCodeActions: function getCodeActionsToDisableJsDiagnostics(context) {
           const { sourceFile, program, span, host, formatContext } = context;
           if (!isInJSFile(sourceFile) || !isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) {
@@ -145447,14 +145708,14 @@ ${lanes.join("\n")}
             )
           ];
           if (ts_textChanges_exports.isValidLocationToAddComment(sourceFile, span.start)) {
-            fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId39, Diagnostics.Add_ts_ignore_to_all_error_messages));
+            fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId40, Diagnostics.Add_ts_ignore_to_all_error_messages));
           }
           return fixes;
         },
-        fixIds: [fixId39],
+        fixIds: [fixId40],
         getAllCodeActions: (context) => {
           const seenLines = /* @__PURE__ */ new Set();
-          return codeFixAll(context, errorCodes49, (changes, diag2) => {
+          return codeFixAll(context, errorCodes50, (changes, diag2) => {
             if (ts_textChanges_exports.isValidLocationToAddComment(diag2.file, diag2.start)) {
               makeChange8(changes, diag2.file, diag2.start, seenLines);
             }
@@ -146551,7 +146812,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  var fixName6, fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer, errorCodes50;
+  var fixName6, fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer, errorCodes51;
   var init_fixStrictClassInitialization = __esm({
     "src/services/codefixes/fixStrictClassInitialization.ts"() {
       "use strict";
@@ -146561,9 +146822,9 @@ ${lanes.join("\n")}
       fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions";
       fixIdAddUndefinedType = "addMissingPropertyUndefinedType";
       fixIdAddInitializer = "addMissingPropertyInitializer";
-      errorCodes50 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
+      errorCodes51 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
       registerCodeFix({
-        errorCodes: errorCodes50,
+        errorCodes: errorCodes51,
         getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) {
           const info = getInfo13(context.sourceFile, context.span.start);
           if (!info)
@@ -146576,7 +146837,7 @@ ${lanes.join("\n")}
         },
         fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes50, (changes, diag2) => {
+          return codeFixAll(context, errorCodes51, (changes, diag2) => {
             const info = getInfo13(diag2.file, diag2.start);
             if (!info)
               return;
@@ -146604,7 +146865,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/requireInTs.ts
-  function doChange25(changes, sourceFile, info) {
+  function doChange27(changes, sourceFile, info) {
     const { allowSyntheticDefaults, defaultImportName, namedImports, statement, required } = info;
     changes.replaceNode(sourceFile, statement, defaultImportName && !allowSyntheticDefaults ? factory.createImportEqualsDeclaration(
       /*modifiers*/
@@ -146666,29 +146927,29 @@ ${lanes.join("\n")}
       return factory.createNamedImports(importSpecifiers);
     }
   }
-  var fixId40, errorCodes51;
+  var fixId41, errorCodes52;
   var init_requireInTs = __esm({
     "src/services/codefixes/requireInTs.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId40 = "requireInTs";
-      errorCodes51 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
+      fixId41 = "requireInTs";
+      errorCodes52 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
       registerCodeFix({
-        errorCodes: errorCodes51,
+        errorCodes: errorCodes52,
         getCodeActions(context) {
           const info = getInfo14(context.sourceFile, context.program, context.span.start);
           if (!info) {
             return void 0;
           }
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange25(t, context.sourceFile, info));
-          return [createCodeFixAction(fixId40, changes, Diagnostics.Convert_require_to_import, fixId40, Diagnostics.Convert_all_require_to_import)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange27(t, context.sourceFile, info));
+          return [createCodeFixAction(fixId41, changes, Diagnostics.Convert_require_to_import, fixId41, Diagnostics.Convert_all_require_to_import)];
         },
-        fixIds: [fixId40],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes51, (changes, diag2) => {
+        fixIds: [fixId41],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes52, (changes, diag2) => {
           const info = getInfo14(diag2.file, context.program, diag2.start);
           if (info) {
-            doChange25(changes, context.sourceFile, info);
+            doChange27(changes, context.sourceFile, info);
           }
         })
       });
@@ -146708,7 +146969,7 @@ ${lanes.join("\n")}
       return { importNode, name, moduleSpecifier: importNode.moduleSpecifier };
     }
   }
-  function doChange26(changes, sourceFile, info, preferences) {
+  function doChange28(changes, sourceFile, info, preferences) {
     changes.replaceNode(sourceFile, info.importNode, makeImport(
       info.name,
       /*namedImports*/
@@ -146717,29 +146978,29 @@ ${lanes.join("\n")}
       getQuotePreference(sourceFile, preferences)
     ));
   }
-  var fixId41, errorCodes52;
+  var fixId42, errorCodes53;
   var init_useDefaultImport = __esm({
     "src/services/codefixes/useDefaultImport.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId41 = "useDefaultImport";
-      errorCodes52 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
+      fixId42 = "useDefaultImport";
+      errorCodes53 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
       registerCodeFix({
-        errorCodes: errorCodes52,
+        errorCodes: errorCodes53,
         getCodeActions(context) {
           const { sourceFile, span: { start } } = context;
           const info = getInfo15(sourceFile, start);
           if (!info)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange26(t, sourceFile, info, context.preferences));
-          return [createCodeFixAction(fixId41, changes, Diagnostics.Convert_to_default_import, fixId41, Diagnostics.Convert_all_to_default_imports)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange28(t, sourceFile, info, context.preferences));
+          return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_to_default_import, fixId42, Diagnostics.Convert_all_to_default_imports)];
         },
-        fixIds: [fixId41],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes52, (changes, diag2) => {
+        fixIds: [fixId42],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes53, (changes, diag2) => {
           const info = getInfo15(diag2.file, diag2.start);
           if (info)
-            doChange26(changes, diag2.file, info, context.preferences);
+            doChange28(changes, diag2.file, info, context.preferences);
         })
       });
     }
@@ -146754,27 +147015,27 @@ ${lanes.join("\n")}
     const newText = numericLiteral.getText(sourceFile) + "n";
     changeTracker.replaceNode(sourceFile, numericLiteral, factory.createBigIntLiteral(newText));
   }
-  var fixId42, errorCodes53;
+  var fixId43, errorCodes54;
   var init_useBigintLiteral = __esm({
     "src/services/codefixes/useBigintLiteral.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId42 = "useBigintLiteral";
-      errorCodes53 = [
+      fixId43 = "useBigintLiteral";
+      errorCodes54 = [
         Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes53,
+        errorCodes: errorCodes54,
         getCodeActions: function getCodeActionsToUseBigintLiteral(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange9(t, context.sourceFile, context.span));
           if (changes.length > 0) {
-            return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId42, Diagnostics.Convert_all_to_bigint_numeric_literals)];
+            return [createCodeFixAction(fixId43, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId43, Diagnostics.Convert_all_to_bigint_numeric_literals)];
           }
         },
-        fixIds: [fixId42],
+        fixIds: [fixId43],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes53, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
+          return codeFixAll(context, errorCodes54, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
         }
       });
     }
@@ -146787,7 +147048,7 @@ ${lanes.join("\n")}
     Debug.assert(token.parent.kind === 202 /* ImportType */, "Token parent should be an ImportType");
     return token.parent;
   }
-  function doChange27(changes, sourceFile, importType) {
+  function doChange29(changes, sourceFile, importType) {
     const newTypeNode = factory.updateImportTypeNode(
       importType,
       importType.argument,
@@ -146799,25 +147060,25 @@ ${lanes.join("\n")}
     );
     changes.replaceNode(sourceFile, importType, newTypeNode);
   }
-  var fixIdAddMissingTypeof, fixId43, errorCodes54;
+  var fixIdAddMissingTypeof, fixId44, errorCodes55;
   var init_fixAddModuleReferTypeMissingTypeof = __esm({
     "src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof";
-      fixId43 = fixIdAddMissingTypeof;
-      errorCodes54 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
+      fixId44 = fixIdAddMissingTypeof;
+      errorCodes55 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
       registerCodeFix({
-        errorCodes: errorCodes54,
+        errorCodes: errorCodes55,
         getCodeActions: function getCodeActionsToAddMissingTypeof(context) {
           const { sourceFile, span } = context;
           const importType = getImportTypeNode(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange27(t, sourceFile, importType));
-          return [createCodeFixAction(fixId43, changes, Diagnostics.Add_missing_typeof, fixId43, Diagnostics.Add_missing_typeof)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, importType));
+          return [createCodeFixAction(fixId44, changes, Diagnostics.Add_missing_typeof, fixId44, Diagnostics.Add_missing_typeof)];
         },
-        fixIds: [fixId43],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes54, (changes, diag2) => doChange27(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
+        fixIds: [fixId44],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => doChange29(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
       });
     }
   });
@@ -146836,7 +147097,7 @@ ${lanes.join("\n")}
       return void 0;
     return binaryExpr;
   }
-  function doChange28(changeTracker, sf, node) {
+  function doChange30(changeTracker, sf, node) {
     const jsx = flattenInvalidBinaryExpr(node);
     if (jsx)
       changeTracker.replaceNode(sf, node, factory.createJsxFragment(factory.createJsxOpeningFragment(), jsx, factory.createJsxJsxClosingFragment()));
@@ -146859,30 +147120,30 @@ ${lanes.join("\n")}
         return void 0;
     }
   }
-  var fixID2, errorCodes55;
+  var fixID2, errorCodes56;
   var init_wrapJsxInFragment = __esm({
     "src/services/codefixes/wrapJsxInFragment.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixID2 = "wrapJsxInFragment";
-      errorCodes55 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
+      errorCodes56 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
       registerCodeFix({
-        errorCodes: errorCodes55,
+        errorCodes: errorCodes56,
         getCodeActions: function getCodeActionsToWrapJsxInFragment(context) {
           const { sourceFile, span } = context;
           const node = findNodeToFix(sourceFile, span.start);
           if (!node)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange28(t, sourceFile, node));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange30(t, sourceFile, node));
           return [createCodeFixAction(fixID2, changes, Diagnostics.Wrap_in_JSX_fragment, fixID2, Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)];
         },
         fixIds: [fixID2],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => {
           const node = findNodeToFix(context.sourceFile, diag2.start);
           if (!node)
             return void 0;
-          doChange28(changes, context.sourceFile, node);
+          doChange30(changes, context.sourceFile, node);
         })
       });
     }
@@ -146902,7 +147163,7 @@ ${lanes.join("\n")}
   function createTypeAliasFromInterface(declaration, type) {
     return factory.createTypeAliasDeclaration(declaration.modifiers, declaration.name, declaration.typeParameters, type);
   }
-  function doChange29(changes, sourceFile, { indexSignature, container }) {
+  function doChange31(changes, sourceFile, { indexSignature, container }) {
     const members = isInterfaceDeclaration(container) ? container.members : container.type.members;
     const otherMembers = members.filter((member) => !isIndexSignatureDeclaration(member));
     const parameter = first(indexSignature.parameters);
@@ -146929,48 +147190,48 @@ ${lanes.join("\n")}
     ]);
     changes.replaceNode(sourceFile, container, createTypeAliasFromInterface(container, intersectionType));
   }
-  var fixId44, errorCodes56;
+  var fixId45, errorCodes57;
   var init_convertToMappedObjectType = __esm({
     "src/services/codefixes/convertToMappedObjectType.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId44 = "fixConvertToMappedObjectType";
-      errorCodes56 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
+      fixId45 = "fixConvertToMappedObjectType";
+      errorCodes57 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
       registerCodeFix({
-        errorCodes: errorCodes56,
+        errorCodes: errorCodes57,
         getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) {
           const { sourceFile, span } = context;
           const info = getInfo16(sourceFile, span.start);
           if (!info)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, info));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange31(t, sourceFile, info));
           const name = idText(info.container.name);
-          return [createCodeFixAction(fixId44, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId44, [Diagnostics.Convert_0_to_mapped_object_type, name])];
+          return [createCodeFixAction(fixId45, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId45, [Diagnostics.Convert_0_to_mapped_object_type, name])];
         },
-        fixIds: [fixId44],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => {
+        fixIds: [fixId45],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes57, (changes, diag2) => {
           const info = getInfo16(diag2.file, diag2.start);
           if (info)
-            doChange29(changes, diag2.file, info);
+            doChange31(changes, diag2.file, info);
         })
       });
     }
   });
 
   // src/services/codefixes/removeAccidentalCallParentheses.ts
-  var fixId45, errorCodes57;
+  var fixId46, errorCodes58;
   var init_removeAccidentalCallParentheses = __esm({
     "src/services/codefixes/removeAccidentalCallParentheses.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId45 = "removeAccidentalCallParentheses";
-      errorCodes57 = [
+      fixId46 = "removeAccidentalCallParentheses";
+      errorCodes58 = [
         Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes57,
+        errorCodes: errorCodes58,
         getCodeActions(context) {
           const callExpression = findAncestor(getTokenAtPosition(context.sourceFile, context.span.start), isCallExpression);
           if (!callExpression) {
@@ -146979,9 +147240,9 @@ ${lanes.join("\n")}
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
             t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end });
           });
-          return [createCodeFixActionWithoutFixAll(fixId45, changes, Diagnostics.Remove_parentheses)];
+          return [createCodeFixActionWithoutFixAll(fixId46, changes, Diagnostics.Remove_parentheses)];
         },
-        fixIds: [fixId45]
+        fixIds: [fixId46]
       });
     }
   });
@@ -147010,27 +147271,27 @@ ${lanes.join("\n")}
     }
     changeTracker.replaceNode(sourceFile, expressionToReplace, awaitExpression.expression);
   }
-  var fixId46, errorCodes58;
+  var fixId47, errorCodes59;
   var init_removeUnnecessaryAwait = __esm({
     "src/services/codefixes/removeUnnecessaryAwait.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId46 = "removeUnnecessaryAwait";
-      errorCodes58 = [
+      fixId47 = "removeUnnecessaryAwait";
+      errorCodes59 = [
         Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes58,
+        errorCodes: errorCodes59,
         getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span));
           if (changes.length > 0) {
-            return [createCodeFixAction(fixId46, changes, Diagnostics.Remove_unnecessary_await, fixId46, Diagnostics.Remove_all_unnecessary_uses_of_await)];
+            return [createCodeFixAction(fixId47, changes, Diagnostics.Remove_unnecessary_await, fixId47, Diagnostics.Remove_all_unnecessary_uses_of_await)];
           }
         },
-        fixIds: [fixId46],
+        fixIds: [fixId47],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes58, (changes, diag2) => makeChange10(changes, diag2.file, diag2));
+          return codeFixAll(context, errorCodes59, (changes, diag2) => makeChange10(changes, diag2.file, diag2));
         }
       });
     }
@@ -147072,26 +147333,26 @@ ${lanes.join("\n")}
       importDeclaration.assertClause
     ));
   }
-  var errorCodes59, fixId47;
+  var errorCodes60, fixId48;
   var init_splitTypeOnlyImport = __esm({
     "src/services/codefixes/splitTypeOnlyImport.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes59 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
-      fixId47 = "splitTypeOnlyImport";
+      errorCodes60 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
+      fixId48 = "splitTypeOnlyImport";
       registerCodeFix({
-        errorCodes: errorCodes59,
-        fixIds: [fixId47],
+        errorCodes: errorCodes60,
+        fixIds: [fixId48],
         getCodeActions: function getCodeActionsToSplitTypeOnlyImport(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
             return splitTypeOnlyImport(t, getImportDeclaration2(context.sourceFile, context.span), context);
           });
           if (changes.length) {
-            return [createCodeFixAction(fixId47, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId47, Diagnostics.Split_all_invalid_type_only_imports)];
+            return [createCodeFixAction(fixId48, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId48, Diagnostics.Split_all_invalid_type_only_imports)];
           }
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, error) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes60, (changes, error) => {
           splitTypeOnlyImport(changes, getImportDeclaration2(context.sourceFile, error), context);
         })
       });
@@ -147113,43 +147374,43 @@ ${lanes.join("\n")}
       return;
     return { symbol, token: constToken };
   }
-  function doChange30(changes, sourceFile, token) {
+  function doChange32(changes, sourceFile, token) {
     changes.replaceNode(sourceFile, token, factory.createToken(119 /* LetKeyword */));
   }
-  var fixId48, errorCodes60;
+  var fixId49, errorCodes61;
   var init_convertConstToLet = __esm({
     "src/services/codefixes/convertConstToLet.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId48 = "fixConvertConstToLet";
-      errorCodes60 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
+      fixId49 = "fixConvertConstToLet";
+      errorCodes61 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
       registerCodeFix({
-        errorCodes: errorCodes60,
+        errorCodes: errorCodes61,
         getCodeActions: function getCodeActionsToConvertConstToLet(context) {
           const { sourceFile, span, program } = context;
           const info = getInfo17(sourceFile, span.start, program);
           if (info === void 0)
             return;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange30(t, sourceFile, info.token));
-          return [createCodeFixActionMaybeFixAll(fixId48, changes, Diagnostics.Convert_const_to_let, fixId48, Diagnostics.Convert_all_const_to_let)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange32(t, sourceFile, info.token));
+          return [createCodeFixActionMaybeFixAll(fixId49, changes, Diagnostics.Convert_const_to_let, fixId49, Diagnostics.Convert_all_const_to_let)];
         },
         getAllCodeActions: (context) => {
           const { program } = context;
           const seen = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes60, (diag2) => {
+            eachDiagnostic(context, errorCodes61, (diag2) => {
               const info = getInfo17(diag2.file, diag2.start, program);
               if (info) {
                 if (addToSeen(seen, getSymbolId(info.symbol))) {
-                  return doChange30(changes, diag2.file, info.token);
+                  return doChange32(changes, diag2.file, info.token);
                 }
               }
               return void 0;
             });
           }));
         },
-        fixIds: [fixId48]
+        fixIds: [fixId49]
       });
     }
   });
@@ -147159,40 +147420,40 @@ ${lanes.join("\n")}
     const node = getTokenAtPosition(sourceFile, pos);
     return node.kind === 26 /* SemicolonToken */ && node.parent && (isObjectLiteralExpression(node.parent) || isArrayLiteralExpression(node.parent)) ? { node } : void 0;
   }
-  function doChange31(changes, sourceFile, { node }) {
+  function doChange33(changes, sourceFile, { node }) {
     const newNode = factory.createToken(27 /* CommaToken */);
     changes.replaceNode(sourceFile, node, newNode);
   }
-  var fixId49, expectedErrorCode, errorCodes61;
+  var fixId50, expectedErrorCode, errorCodes62;
   var init_fixExpectedComma = __esm({
     "src/services/codefixes/fixExpectedComma.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId49 = "fixExpectedComma";
+      fixId50 = "fixExpectedComma";
       expectedErrorCode = Diagnostics._0_expected.code;
-      errorCodes61 = [expectedErrorCode];
+      errorCodes62 = [expectedErrorCode];
       registerCodeFix({
-        errorCodes: errorCodes61,
+        errorCodes: errorCodes62,
         getCodeActions(context) {
           const { sourceFile } = context;
           const info = getInfo18(sourceFile, context.span.start, context.errorCode);
           if (!info)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange31(t, sourceFile, info));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange33(t, sourceFile, info));
           return [createCodeFixAction(
-            fixId49,
+            fixId50,
             changes,
             [Diagnostics.Change_0_to_1, ";", ","],
-            fixId49,
+            fixId50,
             [Diagnostics.Change_0_to_1, ";", ","]
           )];
         },
-        fixIds: [fixId49],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes61, (changes, diag2) => {
+        fixIds: [fixId50],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes62, (changes, diag2) => {
           const info = getInfo18(diag2.file, diag2.start, diag2.code);
           if (info)
-            doChange31(changes, context.sourceFile, info);
+            doChange33(changes, context.sourceFile, info);
         })
       });
     }
@@ -147248,29 +147509,29 @@ ${lanes.join("\n")}
       return node.typeArguments;
     }
   }
-  var fixName7, fixId50, errorCodes62;
+  var fixName7, fixId51, errorCodes63;
   var init_fixAddVoidToPromise = __esm({
     "src/services/codefixes/fixAddVoidToPromise.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixName7 = "addVoidToPromise";
-      fixId50 = "addVoidToPromise";
-      errorCodes62 = [
+      fixId51 = "addVoidToPromise";
+      errorCodes63 = [
         Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code,
         Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes62,
-        fixIds: [fixId50],
+        errorCodes: errorCodes63,
+        fixIds: [fixId51],
         getCodeActions(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span, context.program));
           if (changes.length > 0) {
-            return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId50, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
+            return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId51, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
           }
         },
         getAllCodeActions(context) {
-          return codeFixAll(context, errorCodes62, (changes, diag2) => makeChange11(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
+          return codeFixAll(context, errorCodes63, (changes, diag2) => makeChange11(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
         }
       });
     }
@@ -147305,6 +147566,7 @@ ${lanes.join("\n")}
     getFixes: () => getFixes,
     getImportCompletionAction: () => getImportCompletionAction,
     getImportKind: () => getImportKind,
+    getJSDocTypedefNode: () => getJSDocTypedefNode,
     getNoopSymbolTrackerWithResolver: () => getNoopSymbolTrackerWithResolver,
     getPromoteTypeOnlyCompletionAction: () => getPromoteTypeOnlyCompletionAction,
     getSupportedErrorCodes: () => getSupportedErrorCodes,
@@ -147339,6 +147601,7 @@ ${lanes.join("\n")}
       init_correctQualifiedNameToIndexedAccessType();
       init_convertToTypeOnlyExport();
       init_convertToTypeOnlyImport();
+      init_convertTypedefToType();
       init_convertLiteralTypeToMappedType();
       init_fixClassIncorrectlyImplementsInterface();
       init_importFixes();
@@ -156488,7 +156751,7 @@ ${lanes.join("\n")}
         return void 0;
     }
   }
-  function doChange32(exportingSourceFile, program, info, changes, cancellationToken) {
+  function doChange34(exportingSourceFile, program, info, changes, cancellationToken) {
     changeExport(exportingSourceFile, info, changes, program.getTypeChecker());
     changeImports(program, info, changes, cancellationToken);
   }
@@ -156684,7 +156947,7 @@ ${lanes.join("\n")}
           Debug.assert(actionName2 === defaultToNamedAction.name || actionName2 === namedToDefaultAction.name, "Unexpected action name");
           const info = getInfo19(context);
           Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
-          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange32(context.file, context.program, info, t, context.cancellationToken));
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(context.file, context.program, info, t, context.cancellationToken));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
         }
       });
@@ -156719,7 +156982,7 @@ ${lanes.join("\n")}
   function getShouldUseDefault(program, importClause) {
     return getAllowSyntheticDefaultImports(program.getCompilerOptions()) && isExportEqualsModule(importClause.parent.moduleSpecifier, program.getTypeChecker());
   }
-  function doChange33(sourceFile, program, changes, info) {
+  function doChange35(sourceFile, program, changes, info) {
     const checker = program.getTypeChecker();
     if (info.convertTo === 0 /* Named */) {
       doChangeNamespaceToNamed(sourceFile, checker, changes, info.import, getAllowSyntheticDefaultImports(program.getCompilerOptions()));
@@ -156911,7 +157174,7 @@ ${lanes.join("\n")}
           Debug.assert(some(getOwnValues(actions), (action) => action.name === actionName2), "Unexpected action name");
           const info = getImportConversionInfo(context);
           Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
-          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange33(context.file, context.program, t, info));
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(context.file, context.program, t, info));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
         }
       });
@@ -157253,7 +157516,7 @@ ${lanes.join("\n")}
       afterLast: afterEndNodeIndex === -1 ? void 0 : statements[afterEndNodeIndex]
     };
   }
-  function doChange34(oldFile, program, toMove, changes, host, preferences) {
+  function doChange36(oldFile, program, toMove, changes, host, preferences) {
     const checker = program.getTypeChecker();
     const usage = getUsageInfo(oldFile, toMove.all, checker);
     const currentDirectory = getDirectoryPath(oldFile.fileName);
@@ -158023,7 +158286,7 @@ ${lanes.join("\n")}
         getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName2) {
           Debug.assert(actionName2 === refactorName4, "Wrong refactor invoked");
           const statements = Debug.checkDefined(getStatementsToMove(context));
-          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(context.file, context.program, statements, t, context.host, context.preferences));
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange36(context.file, context.program, statements, t, context.host, context.preferences));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
         }
       });
@@ -158685,12 +158948,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return void 0;
     const groupedReferences = getGroupedReferences(functionDeclaration, program, cancellationToken);
     if (groupedReferences.valid) {
-      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(file, program, host, t, functionDeclaration, groupedReferences));
+      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange37(file, program, host, t, functionDeclaration, groupedReferences));
       return { renameFilename: void 0, renameLocation: void 0, edits };
     }
     return { edits: [] };
   }
-  function doChange35(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
+  function doChange37(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
     const signature = groupedReferences.signature;
     const newFunctionDeclarationParams = map(createNewParameters(functionDeclaration, program, host), (param) => getSynthesizedDeepClone(param));
     if (signature) {
@@ -159483,7 +159746,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
     const edits = ts_textChanges_exports.ChangeTracker.with(
       context,
-      (t) => doChange36(context.file, context.program.getTypeChecker(), t, info, actionName2)
+      (t) => doChange38(context.file, context.program.getTypeChecker(), t, info, actionName2)
     );
     return { edits, renameFilename: void 0, renameLocation: void 0 };
   }
@@ -159639,7 +159902,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return toConvert;
   }
-  function doChange36(sourceFile, checker, changes, info, _actionName) {
+  function doChange38(sourceFile, checker, changes, info, _actionName) {
     const { finalExpression, occurrences, expression } = info;
     const firstOccurrence = occurrences[occurrences.length - 1];
     const convertedChain = convertOccurrences(checker, finalExpression, occurrences);
@@ -161375,7 +161638,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function getRefactorEditsToInferReturnType(context) {
     const info = getInfo21(context);
     if (info && !isRefactorErrorInfo(info)) {
-      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange37(context.file, t, info.declaration, info.returnTypeNode));
+      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange39(context.file, t, info.declaration, info.returnTypeNode));
       return { renameFilename: void 0, renameLocation: void 0, edits };
     }
     return void 0;
@@ -161400,7 +161663,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return emptyArray;
   }
-  function doChange37(sourceFile, changes, declaration, typeNode) {
+  function doChange39(sourceFile, changes, declaration, typeNode) {
     const closeParen = findChildOfKind(declaration, 21 /* CloseParenToken */, sourceFile);
     const needParens = isArrowFunction(declaration) && closeParen === void 0;
     const endNode2 = needParens ? first(declaration.parameters) : closeParen;
@@ -167667,7 +167930,6 @@ ${options.prefix}` : "\n" : options.prefix
         CommandTypes2["NavtoFull"] = "navto-full";
         CommandTypes2["NavTree"] = "navtree";
         CommandTypes2["NavTreeFull"] = "navtree-full";
-        CommandTypes2["Occurrences"] = "occurrences";
         CommandTypes2["DocumentHighlights"] = "documentHighlights";
         CommandTypes2["DocumentHighlightsFull"] = "documentHighlights-full";
         CommandTypes2["Open"] = "open";
@@ -167924,17 +168186,14 @@ ${options.prefix}` : "\n" : options.prefix
            * True when reloading contents of file from the disk is pending
            */
           this.pendingReloadFromDisk = false;
-          this.version = initialVersion || { svc: 0, text: 0 };
+          this.version = initialVersion || 0;
         }
         getVersion() {
-          return this.svc ? `SVC-${this.version.svc}-${this.svc.getSnapshotVersion()}` : `Text-${this.version.text}`;
+          return this.svc ? `SVC-${this.version}-${this.svc.getSnapshotVersion()}` : `Text-${this.version}`;
         }
         hasScriptVersionCache_TestOnly() {
           return this.svc !== void 0;
         }
-        useScriptVersionCache_TestOnly() {
-          this.switchToScriptVersionCache();
-        }
         resetSourceMapInfo() {
           this.info.sourceFileLike = void 0;
           this.info.closeSourceMapFileWatcher();
@@ -167947,15 +168206,17 @@ ${options.prefix}` : "\n" : options.prefix
         useText(newText) {
           this.svc = void 0;
           this.text = newText;
+          this.textSnapshot = void 0;
           this.lineMap = void 0;
           this.fileSize = void 0;
           this.resetSourceMapInfo();
-          this.version.text++;
+          this.version++;
         }
         edit(start, end, newText) {
           this.switchToScriptVersionCache().edit(start, end - start, newText);
           this.ownFileText = false;
           this.text = void 0;
+          this.textSnapshot = void 0;
           this.lineMap = void 0;
           this.fileSize = void 0;
           this.resetSourceMapInfo();
@@ -167967,6 +168228,9 @@ ${options.prefix}` : "\n" : options.prefix
         reload(newText) {
           Debug.assert(newText !== void 0);
           this.pendingReloadFromDisk = false;
+          if (!this.text && this.svc) {
+            this.text = getSnapshotText(this.svc.getSnapshot());
+          }
           if (this.text !== newText) {
             this.useText(newText);
             this.ownFileText = false;
@@ -167979,21 +168243,18 @@ ${options.prefix}` : "\n" : options.prefix
          * returns true if text changed
          */
         reloadWithFileText(tempFileName) {
-          const { text: newText, fileSize } = this.getFileTextAndSize(tempFileName);
+          const { text: newText, fileSize } = tempFileName || !this.info.isDynamicOrHasMixedContent() ? this.getFileTextAndSize(tempFileName) : { text: "", fileSize: void 0 };
           const reloaded = this.reload(newText);
           this.fileSize = fileSize;
           this.ownFileText = !tempFileName || tempFileName === this.info.fileName;
           return reloaded;
         }
         /**
-         * Reloads the contents from the file if there is no pending reload from disk or the contents of file are same as file text
-         * returns true if text changed
+         * Schedule reload from the disk if its not already scheduled and its not own text
+         * returns true when scheduling reload
          */
-        reloadFromDisk() {
-          if (!this.pendingReloadFromDisk && !this.ownFileText) {
-            return this.reloadWithFileText();
-          }
-          return false;
+        scheduleReloadIfNeeded() {
+          return !this.pendingReloadFromDisk && !this.ownFileText ? this.pendingReloadFromDisk = true : false;
         }
         delayReloadFromFileIntoText() {
           this.pendingReloadFromDisk = true;
@@ -168009,39 +168270,48 @@ ${options.prefix}` : "\n" : options.prefix
           return !!this.fileSize ? this.fileSize : !!this.text ? this.text.length : !!this.svc ? this.svc.getSnapshot().getLength() : this.getSnapshot().getLength();
         }
         getSnapshot() {
-          return this.useScriptVersionCacheIfValidOrOpen() ? this.svc.getSnapshot() : ScriptSnapshot.fromString(this.getOrLoadText());
+          var _a2, _b;
+          return ((_a2 = this.tryUseScriptVersionCache()) == null ? void 0 : _a2.getSnapshot()) || ((_b = this.textSnapshot) != null ? _b : this.textSnapshot = ScriptSnapshot.fromString(Debug.checkDefined(this.text)));
         }
-        getAbsolutePositionAndLineText(line) {
-          return this.switchToScriptVersionCache().getAbsolutePositionAndLineText(line);
+        getAbsolutePositionAndLineText(oneBasedLine) {
+          const svc = this.tryUseScriptVersionCache();
+          if (svc)
+            return svc.getAbsolutePositionAndLineText(oneBasedLine);
+          const lineMap = this.getLineMap();
+          return oneBasedLine <= lineMap.length ? {
+            absolutePosition: lineMap[oneBasedLine - 1],
+            lineText: this.text.substring(lineMap[oneBasedLine - 1], lineMap[oneBasedLine])
+          } : {
+            absolutePosition: this.text.length,
+            lineText: void 0
+          };
         }
         /**
          *  @param line 0 based index
          */
         lineToTextSpan(line) {
-          if (!this.useScriptVersionCacheIfValidOrOpen()) {
-            const lineMap = this.getLineMap();
-            const start = lineMap[line];
-            const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
-            return createTextSpanFromBounds(start, end);
-          }
-          return this.svc.lineToTextSpan(line);
+          const svc = this.tryUseScriptVersionCache();
+          if (svc)
+            return svc.lineToTextSpan(line);
+          const lineMap = this.getLineMap();
+          const start = lineMap[line];
+          const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
+          return createTextSpanFromBounds(start, end);
         }
         /**
          * @param line 1 based index
          * @param offset 1 based index
          */
         lineOffsetToPosition(line, offset, allowEdits) {
-          if (!this.useScriptVersionCacheIfValidOrOpen()) {
-            return computePositionOfLineAndCharacter(this.getLineMap(), line - 1, offset - 1, this.text, allowEdits);
-          }
-          return this.svc.lineOffsetToPosition(line, offset);
+          const svc = this.tryUseScriptVersionCache();
+          return svc ? svc.lineOffsetToPosition(line, offset) : computePositionOfLineAndCharacter(this.getLineMap(), line - 1, offset - 1, this.text, allowEdits);
         }
         positionToLineOffset(position) {
-          if (!this.useScriptVersionCacheIfValidOrOpen()) {
-            const { line, character } = computeLineAndCharacterOfPosition(this.getLineMap(), position);
-            return { line: line + 1, offset: character + 1 };
-          }
-          return this.svc.positionToLineOffset(position);
+          const svc = this.tryUseScriptVersionCache();
+          if (svc)
+            return svc.positionToLineOffset(position);
+          const { line, character } = computeLineAndCharacterOfPosition(this.getLineMap(), position);
+          return { line: line + 1, offset: character + 1 };
         }
         getFileTextAndSize(tempFileName) {
           let text;
@@ -168059,19 +168329,25 @@ ${options.prefix}` : "\n" : options.prefix
           }
           return { text: getText() };
         }
+        /** @internal */
         switchToScriptVersionCache() {
           if (!this.svc || this.pendingReloadFromDisk) {
             this.svc = ScriptVersionCache.fromString(this.getOrLoadText());
-            this.version.svc++;
+            this.textSnapshot = void 0;
+            this.version++;
           }
           return this.svc;
         }
-        useScriptVersionCacheIfValidOrOpen() {
-          if (this.isOpen) {
-            return this.switchToScriptVersionCache();
+        tryUseScriptVersionCache() {
+          if (!this.svc || this.pendingReloadFromDisk) {
+            this.getOrLoadText();
           }
-          if (this.pendingReloadFromDisk) {
-            this.reloadWithFileText();
+          if (this.isOpen) {
+            if (!this.svc && !this.textSnapshot) {
+              this.svc = ScriptVersionCache.fromString(Debug.checkDefined(this.text));
+              this.textSnapshot = void 0;
+            }
+            return this.svc;
           }
           return this.svc;
         }
@@ -168084,13 +168360,14 @@ ${options.prefix}` : "\n" : options.prefix
         }
         getLineMap() {
           Debug.assert(!this.svc, "ScriptVersionCache should not be set");
-          return this.lineMap || (this.lineMap = computeLineStarts(this.getOrLoadText()));
+          return this.lineMap || (this.lineMap = computeLineStarts(Debug.checkDefined(this.text)));
         }
         getLineInfo() {
-          if (this.svc) {
+          const svc = this.tryUseScriptVersionCache();
+          if (svc) {
             return {
-              getLineCount: () => this.svc.getLineCount(),
-              getLineText: (line) => this.svc.getAbsolutePositionAndLineText(line + 1).lineText
+              getLineCount: () => svc.getLineCount(),
+              getLineText: (line) => svc.getAbsolutePositionAndLineText(line + 1).lineText
             };
           }
           const lineMap = this.getLineMap();
@@ -168111,20 +168388,11 @@ ${options.prefix}` : "\n" : options.prefix
           this.isDynamic = isDynamicFileName(fileName);
           this.textStorage = new TextStorage(host, this, initialVersion);
           if (hasMixedContent || this.isDynamic) {
-            this.textStorage.reload("");
             this.realpath = this.path;
           }
           this.scriptKind = scriptKind ? scriptKind : getScriptKindFromFileName(fileName);
         }
         /** @internal */
-        getVersion() {
-          return this.textStorage.version;
-        }
-        /** @internal */
-        getTelemetryFileSize() {
-          return this.textStorage.getTelemetryFileSize();
-        }
-        /** @internal */
         isDynamicOrHasMixedContent() {
           return this.hasMixedContent || this.isDynamic;
         }
@@ -168139,11 +168407,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         close(fileExists = true) {
           this.textStorage.isOpen = false;
-          if (this.isDynamicOrHasMixedContent() || !fileExists) {
-            if (this.textStorage.reload("")) {
-              this.markContainingProjectsAsDirty();
-            }
-          } else if (this.textStorage.reloadFromDisk()) {
+          if (fileExists && this.textStorage.scheduleReloadIfNeeded()) {
             this.markContainingProjectsAsDirty();
           }
         }
@@ -168323,22 +168587,12 @@ ${options.prefix}` : "\n" : options.prefix
           this.markContainingProjectsAsDirty();
         }
         reloadFromFile(tempFileName) {
-          if (this.isDynamicOrHasMixedContent()) {
-            this.textStorage.reload("");
+          if (this.textStorage.reloadWithFileText(tempFileName)) {
             this.markContainingProjectsAsDirty();
             return true;
-          } else {
-            if (this.textStorage.reloadWithFileText(tempFileName)) {
-              this.markContainingProjectsAsDirty();
-              return true;
-            }
           }
           return false;
         }
-        /** @internal */
-        getAbsolutePositionAndLineText(line) {
-          return this.textStorage.getAbsolutePositionAndLineText(line);
-        }
         editContent(start, end, newText) {
           this.textStorage.edit(start, end, newText);
           this.markContainingProjectsAsDirty();
@@ -168378,10 +168632,6 @@ ${options.prefix}` : "\n" : options.prefix
           return this.scriptKind === 1 /* JS */ || this.scriptKind === 2 /* JSX */;
         }
         /** @internal */
-        getLineInfo() {
-          return this.textStorage.getLineInfo();
-        }
-        /** @internal */
         closeSourceMapFileWatcher() {
           if (this.sourceMapFilePath && !isString(this.sourceMapFilePath)) {
             closeFileWatcherOf(this.sourceMapFilePath);
@@ -168512,7 +168762,7 @@ ${options.prefix}` : "\n" : options.prefix
       deferredSize: 0
     };
     for (const info of infos) {
-      const fileSize = includeSizes ? info.getTelemetryFileSize() : 0;
+      const fileSize = includeSizes ? info.textStorage.getTelemetryFileSize() : 0;
       switch (info.scriptKind) {
         case 1 /* JS */:
           result.js += 1;
@@ -169542,10 +169792,26 @@ ${options.prefix}` : "\n" : options.prefix
           const elapsed = timestamp() - start;
           this.sendPerformanceEvent("UpdateGraph", elapsed);
           this.writeLog(`Finishing updateGraphWorker: Project: ${this.getProjectName()} Version: ${this.getProjectVersion()} structureChanged: ${hasNewProgram}${this.program ? ` structureIsReused:: ${StructureIsReused[this.program.structureIsReused]}` : ""} Elapsed: ${elapsed}ms`);
-          if (this.hasAddedorRemovedFiles) {
+          if (this.projectService.logger.isTestLogger) {
+            if (this.program !== oldProgram) {
+              this.print(
+                /*writeProjectFileNames*/
+                true,
+                this.hasAddedorRemovedFiles,
+                /*writeFileVersionAndText*/
+                true
+              );
+            } else {
+              this.writeLog(`Same program as before`);
+            }
+          } else if (this.hasAddedorRemovedFiles) {
             this.print(
               /*writeProjectFileNames*/
-              true
+              true,
+              /*writeFileExplaination*/
+              true,
+              /*writeFileVersionAndText*/
+              false
             );
           } else if (this.program !== oldProgram) {
             this.writeLog(`Different program with same set of files`);
@@ -169655,6 +169921,16 @@ ${options.prefix}` : "\n" : options.prefix
           return this.projectService.getScriptInfo(uncheckedFileName);
         }
         filesToString(writeProjectFileNames) {
+          return this.filesToStringWorker(
+            writeProjectFileNames,
+            /*writeFileExplaination*/
+            true,
+            /*writeFileVersionAndText*/
+            false
+          );
+        }
+        /** @internal */
+        filesToStringWorker(writeProjectFileNames, writeFileExplaination, writeFileVersionAndText) {
           if (this.isInitialLoadPending())
             return "	Files (0) InitialLoadPending\n";
           if (!this.program)
@@ -169664,23 +169940,33 @@ ${options.prefix}` : "\n" : options.prefix
 `;
           if (writeProjectFileNames) {
             for (const file of sourceFiles) {
-              strBuilder += `	${file.fileName}
+              strBuilder += `	${file.fileName}${writeFileVersionAndText ? ` ${file.version} ${JSON.stringify(file.text)}` : ""}
 `;
             }
-            strBuilder += "\n\n";
-            explainFiles(this.program, (s) => strBuilder += `	${s}
+            if (writeFileExplaination) {
+              strBuilder += "\n\n";
+              explainFiles(this.program, (s) => strBuilder += `	${s}
 `);
+            }
           }
           return strBuilder;
         }
         /** @internal */
-        print(writeProjectFileNames) {
+        print(writeProjectFileNames, writeFileExplaination, writeFileVersionAndText) {
           this.writeLog(`Project '${this.projectName}' (${ProjectKind[this.projectKind]})`);
-          this.writeLog(this.filesToString(writeProjectFileNames && this.projectService.logger.hasLevel(3 /* verbose */)));
+          this.writeLog(this.filesToStringWorker(
+            writeProjectFileNames && this.projectService.logger.hasLevel(3 /* verbose */),
+            writeFileExplaination && this.projectService.logger.hasLevel(3 /* verbose */),
+            writeFileVersionAndText && this.projectService.logger.hasLevel(3 /* verbose */)
+          ));
           this.writeLog("-----------------------------------------------");
           if (this.autoImportProviderHost) {
             this.autoImportProviderHost.print(
               /*writeProjectFileNames*/
+              false,
+              /*writeFileExplaination*/
+              false,
+              /*writeFileVersionAndText*/
               false
             );
           }
@@ -170682,7 +170968,7 @@ ${options.prefix}` : "\n" : options.prefix
           return !!this.externalProjectRefCount;
         }
         getEffectiveTypeRoots() {
-          return getEffectiveTypeRoots(this.getCompilationSettings(), this.directoryStructureHost) || [];
+          return getEffectiveTypeRoots(this.getCompilationSettings(), this) || [];
         }
         /** @internal */
         updateErrorOnNoInputFiles(fileNames) {
@@ -170931,6 +171217,10 @@ ${options.prefix}` : "\n" : options.prefix
   function printProjectWithoutFileNames(project) {
     project.print(
       /*writeProjectFileNames*/
+      false,
+      /*writeFileExplaination*/
+      false,
+      /*writeFileVersionAndText*/
       false
     );
   }
@@ -171635,7 +171925,11 @@ ${options.prefix}` : "\n" : options.prefix
           this.logger.info("`remove Project::");
           project.print(
             /*writeProjectFileNames*/
-            true
+            true,
+            /*writeFileExplaination*/
+            true,
+            /*writeFileVersionAndText*/
+            false
           );
           project.close();
           if (Debug.shouldAssert(1 /* Normal */)) {
@@ -171774,7 +172068,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         deleteScriptInfo(info) {
           this.filenameToScriptInfo.delete(info.path);
-          this.filenameToScriptInfoVersion.set(info.path, info.getVersion());
+          this.filenameToScriptInfoVersion.set(info.path, info.textStorage.version);
           const realpath = info.getRealpathIfDifferent();
           if (realpath) {
             this.realpathToScriptInfos.remove(realpath, info);
@@ -172858,7 +173152,7 @@ Dynamic files must always be opened with service's current directory or service
           const documentPositionMapper = getDocumentPositionMapper(
             { getCanonicalFileName: this.toCanonicalFileName, log: (s) => this.logger.info(s), getSourceFileLike: (f) => this.getSourceFileLike(f, projectName, declarationInfo) },
             declarationInfo.fileName,
-            declarationInfo.getLineInfo(),
+            declarationInfo.textStorage.getLineInfo(),
             readMapFile
           );
           readMapFile = void 0;
@@ -174687,7 +174981,6 @@ ${json}${newLine}`;
         "signatureHelp-full" /* SignatureHelpFull */,
         "navto" /* Navto */,
         "navto-full" /* NavtoFull */,
-        "occurrences" /* Occurrences */,
         "documentHighlights" /* DocumentHighlights */,
         "documentHighlights-full" /* DocumentHighlightsFull */
       ];
@@ -175120,9 +175413,6 @@ ${json}${newLine}`;
                 false
               ));
             },
-            ["occurrences" /* Occurrences */]: (request) => {
-              return this.requiredResponse(this.getOccurrences(request.arguments));
-            },
             ["documentHighlights" /* DocumentHighlights */]: (request) => {
               return this.requiredResponse(this.getDocumentHighlights(
                 request.arguments,
@@ -176085,21 +176375,6 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           const implementations = this.mapImplementationLocations(project.getLanguageService().getImplementationAtPosition(file, position) || emptyArray2, project);
           return simplifiedResult ? implementations.map(({ fileName, textSpan, contextSpan }) => this.toFileSpanWithContext(fileName, textSpan, contextSpan, project)) : implementations.map(Session3.mapToOriginalLocation);
         }
-        getOccurrences(args) {
-          const { file, project } = this.getFileAndProject(args);
-          const position = this.getPositionInFile(args, file);
-          const occurrences = project.getLanguageService().getOccurrencesAtPosition(file, position);
-          return occurrences ? occurrences.map((occurrence) => {
-            const { fileName, isWriteAccess: isWriteAccess2, textSpan, isInString: isInString2, contextSpan } = occurrence;
-            const scriptInfo = project.getScriptInfo(fileName);
-            return {
-              ...toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo),
-              file: fileName,
-              isWriteAccess: isWriteAccess2,
-              ...isInString2 ? { isInString: isInString2 } : void 0
-            };
-          }) : emptyArray2;
-        }
         getSyntacticDiagnosticsSync(args) {
           const { configFile } = this.getConfigFileAndProject(args);
           if (configFile) {
@@ -176510,7 +176785,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
             formatOptions
           );
           if (args.key === "\n" && (!edits || edits.length === 0 || allEditsBeforePos(edits, position))) {
-            const { lineText, absolutePosition } = scriptInfo.getAbsolutePositionAndLineText(args.line);
+            const { lineText, absolutePosition } = scriptInfo.textStorage.getAbsolutePositionAndLineText(args.line);
             if (lineText && lineText.search("\\S") < 0) {
               const preferredIndent = languageService.getIndentationAtPosition(file, position, formatOptions);
               let hasIndent = 0;
@@ -176735,6 +177010,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         change(args) {
           const scriptInfo = this.projectService.getScriptInfo(args.file);
           Debug.assert(!!scriptInfo);
+          scriptInfo.textStorage.switchToScriptVersionCache();
           const start = scriptInfo.lineOffsetToPosition(args.line, args.offset);
           const end = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset);
           if (start >= 0) {
@@ -177027,10 +177303,10 @@ ${e.message}`;
           }
           return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions;
         }
-        getCombinedCodeFix({ scope, fixId: fixId51 }, simplifiedResult) {
+        getCombinedCodeFix({ scope, fixId: fixId52 }, simplifiedResult) {
           Debug.assert(scope.type === "file");
           const { file, project } = this.getFileAndProject(scope.args);
-          const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId51, this.getFormatOptions(file), this.getPreferences(file));
+          const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId52, this.getFormatOptions(file), this.getPreferences(file));
           if (simplifiedResult) {
             return { changes: this.mapTextChangesToCodeEdits(res.changes), commands: res.commands };
           } else {
@@ -177069,8 +177345,8 @@ ${e.message}`;
         mapCodeAction({ description: description2, changes, commands }) {
           return { description: description2, changes: this.mapTextChangesToCodeEdits(changes), commands };
         }
-        mapCodeFixAction({ fixName: fixName8, description: description2, changes, commands, fixId: fixId51, fixAllDescription }) {
-          return { fixName: fixName8, description: description2, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId51, fixAllDescription };
+        mapCodeFixAction({ fixName: fixName8, description: description2, changes, commands, fixId: fixId52, fixAllDescription }) {
+          return { fixName: fixName8, description: description2, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId52, fixAllDescription };
         }
         mapTextChangesToCodeEdits(textChanges2) {
           return textChanges2.map((change) => this.mapTextChangeToCodeEdit(change));
@@ -180100,7 +180376,6 @@ ${e.message}`;
     nodeToDisplayParts: () => nodeToDisplayParts,
     noop: () => noop,
     noopFileWatcher: () => noopFileWatcher,
-    noopPush: () => noopPush,
     normalizePath: () => normalizePath,
     normalizeSlashes: () => normalizeSlashes,
     not: () => not,
@@ -182459,7 +182734,6 @@ ${e.message}`;
     nodeToDisplayParts: () => nodeToDisplayParts,
     noop: () => noop,
     noopFileWatcher: () => noopFileWatcher,
-    noopPush: () => noopPush,
     normalizePath: () => normalizePath,
     normalizeSlashes: () => normalizeSlashes,
     not: () => not,