typescript 5.1.0-dev.20230227 → 5.1.0-dev.20230302

package/lib/tsserver.js

@@ -472,7 +472,6 @@ __export(server_exports, {
   createTypeChecker: () => createTypeChecker,
   createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
   createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
-  createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
   createUnparsedSourceFile: () => createUnparsedSourceFile,
   createWatchCompilerHost: () => createWatchCompilerHost2,
   createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,
@@ -1883,7 +1882,6 @@ __export(server_exports, {
   nodeToDisplayParts: () => nodeToDisplayParts,
   noop: () => noop,
   noopFileWatcher: () => noopFileWatcher,
-  noopPush: () => noopPush,
   normalizePath: () => normalizePath,
   normalizeSlashes: () => normalizeSlashes,
   not: () => not,
@@ -2288,7 +2286,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230227`;
+var version = `${versionMajorMinor}.0-dev.20230302`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3271,9 +3269,6 @@ function multiMapRemove(key, value) {
     }
   }
 }
-function createUnderscoreEscapedMultiMap() {
-  return createMultiMap();
-}
 function createQueue(items) {
   const elements = (items == null ? void 0 : items.slice()) || [];
   let headIndex = 0;
@@ -3446,10 +3441,6 @@ function cast(value, test) {
 }
 function noop(_) {
 }
-var noopPush = {
-  push: noop,
-  length: 0
-};
 function returnFalse() {
   return false;
 }
@@ -10639,6 +10630,7 @@ var Diagnostics = {
   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."),
@@ -11034,6 +11026,8 @@ var Diagnostics = {
   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'"),
@@ -11248,6 +11242,8 @@ var Diagnostics = {
   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?"),
@@ -40956,20 +40952,14 @@ function getEffectiveTypeRoots(options, host) {
     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;
 }
@@ -41106,10 +41096,22 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
       }
       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(
@@ -41129,33 +41131,37 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   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 {
@@ -41987,6 +41993,9 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
         }
         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);
@@ -42167,6 +42176,7 @@ function tryFile(fileName, onlyRecordFailures, state) {
   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) {
@@ -42179,7 +42189,7 @@ function tryFileLookup(fileName, onlyRecordFailures, state) {
       }
     }
   }
-  state.failedLookupLocations.push(fileName);
+  (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(fileName);
   return void 0;
 }
 function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
@@ -42294,8 +42304,8 @@ function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options)
     host,
     compilerOptions: options,
     traceEnabled: isTraceEnabled(options, host),
-    failedLookupLocations: noopPush,
-    affectingLocations: noopPush,
+    failedLookupLocations: void 0,
+    affectingLocations: void 0,
     packageJsonInfoCache,
     features: 0 /* None */,
     conditions: emptyArray,
@@ -42329,24 +42339,24 @@ function getVersionPathsOfPackageJsonInfo(packageJsonInfo, state) {
   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;
     }
   }
@@ -42357,15 +42367,15 @@ function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
       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) {
@@ -43186,11 +43196,13 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
           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));
@@ -43204,6 +43216,31 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
     }
   }
 }
+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);
 }
@@ -52401,7 +52438,7 @@ function createTypeChecker(host) {
           }
         }
         const mayHaveNameCollisions = !(context.flags & 64 /* UseFullyQualifiedType */);
-        const seenNames = mayHaveNameCollisions ? createUnderscoreEscapedMultiMap() : void 0;
+        const seenNames = mayHaveNameCollisions ? createMultiMap() : void 0;
         const result = [];
         let i = 0;
         for (const type of types) {
@@ -56202,7 +56239,11 @@ function createTypeChecker(host) {
       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) {
@@ -64682,7 +64723,7 @@ function createTypeChecker(host) {
               0 /* None */
             );
           }
-        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
+        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => t === target2 || !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
           result2 &= propertiesRelatedTo(
             source2,
             target2,
@@ -64903,6 +64944,7 @@ function createTypeChecker(host) {
       } 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) {
@@ -68048,7 +68090,7 @@ function createTypeChecker(host) {
     );
   }
   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) {
@@ -71196,6 +71238,16 @@ function createTypeChecker(host) {
         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(
@@ -75969,7 +76021,7 @@ function createTypeChecker(host) {
   }
   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);
@@ -80783,6 +80835,9 @@ function createTypeChecker(host) {
       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) {
@@ -90052,6 +90107,7 @@ function createDefaultValueCheck(flattenContext, value, defaultValue, location)
   );
 }
 function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
+  const { factory: factory2 } = flattenContext.context;
   if (isComputedPropertyName(propertyName)) {
     const argumentExpression = ensureIdentifier(
       flattenContext,
@@ -90063,7 +90119,7 @@ function createDestructuringPropertyAccess(flattenContext, value, propertyName)
     );
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else if (isStringOrNumericLiteralLike(propertyName)) {
-    const argumentExpression = factory.cloneNode(propertyName);
+    const argumentExpression = factory2.cloneNode(propertyName);
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else {
     const name = flattenContext.context.factory.createIdentifier(idText(propertyName));
@@ -90138,28 +90194,29 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   if (level === 0 /* LiftRestriction */ && !hasInvalidEscape(template)) {
     return visitEachChild(node, visitor, context);
   }
+  const { factory: factory2 } = context;
   if (isNoSubstitutionTemplateLiteral(template)) {
-    cookedStrings.push(createTemplateCooked(template));
-    rawStrings.push(getRawLiteral(template, currentSourceFile));
+    cookedStrings.push(createTemplateCooked(factory2, template));
+    rawStrings.push(getRawLiteral(factory2, template, currentSourceFile));
   } else {
-    cookedStrings.push(createTemplateCooked(template.head));
-    rawStrings.push(getRawLiteral(template.head, currentSourceFile));
+    cookedStrings.push(createTemplateCooked(factory2, template.head));
+    rawStrings.push(getRawLiteral(factory2, template.head, currentSourceFile));
     for (const templateSpan of template.templateSpans) {
-      cookedStrings.push(createTemplateCooked(templateSpan.literal));
-      rawStrings.push(getRawLiteral(templateSpan.literal, currentSourceFile));
+      cookedStrings.push(createTemplateCooked(factory2, templateSpan.literal));
+      rawStrings.push(getRawLiteral(factory2, templateSpan.literal, currentSourceFile));
       templateArguments.push(Debug.checkDefined(visitNode(templateSpan.expression, visitor, isExpression)));
     }
   }
   const helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(
-    factory.createArrayLiteralExpression(cookedStrings),
-    factory.createArrayLiteralExpression(rawStrings)
+    factory2.createArrayLiteralExpression(cookedStrings),
+    factory2.createArrayLiteralExpression(rawStrings)
   );
   if (isExternalModule(currentSourceFile)) {
-    const tempVar = factory.createUniqueName("templateObject");
+    const tempVar = factory2.createUniqueName("templateObject");
     recordTaggedTemplateString(tempVar);
-    templateArguments[0] = factory.createLogicalOr(
+    templateArguments[0] = factory2.createLogicalOr(
       tempVar,
-      factory.createAssignment(
+      factory2.createAssignment(
         tempVar,
         helperCall
       )
@@ -90167,17 +90224,17 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   } else {
     templateArguments[0] = helperCall;
   }
-  return factory.createCallExpression(
+  return factory2.createCallExpression(
     tag,
     /*typeArguments*/
     void 0,
     templateArguments
   );
 }
-function createTemplateCooked(template) {
-  return template.templateFlags ? factory.createVoidZero() : factory.createStringLiteral(template.text);
+function createTemplateCooked(factory2, template) {
+  return template.templateFlags ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
 }
-function getRawLiteral(node, currentSourceFile) {
+function getRawLiteral(factory2, node, currentSourceFile) {
   let text = node.rawText;
   if (text === void 0) {
     Debug.assertIsDefined(
@@ -90189,7 +90246,7 @@ function getRawLiteral(node, currentSourceFile) {
     text = text.substring(1, text.length - (isLast ? 1 : 2));
   }
   text = text.replace(/\r\n?/g, "\n");
-  return setTextRange(factory.createStringLiteral(text), node);
+  return setTextRange(factory2.createStringLiteral(text), node);
 }
 
 // src/compiler/transformers/ts.ts
@@ -93645,12 +93702,14 @@ function transformClassFields(context) {
         if (privateIdentifierInfo.kind === "f" /* Field */) {
           if (!privateIdentifierInfo.isStatic) {
             return createPrivateInstanceFieldInitializer(
+              factory2,
               receiver,
               visitNode(property.initializer, initializerVisitor, isExpression),
               privateIdentifierInfo.brandCheckIdentifier
             );
           } else {
             return createPrivateStaticFieldInitializer(
+              factory2,
               privateIdentifierInfo.variableName,
               visitNode(property.initializer, initializerVisitor, isExpression)
             );
@@ -93732,7 +93791,7 @@ function transformClassFields(context) {
     Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
     statements.push(
       factory2.createExpressionStatement(
-        createPrivateInstanceMethodInitializer(receiver, weakSetName)
+        createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName)
       )
     );
   }
@@ -94185,25 +94244,25 @@ function transformClassFields(context) {
     return void 0;
   }
 }
-function createPrivateStaticFieldInitializer(variableName, initializer) {
-  return factory.createAssignment(
+function createPrivateStaticFieldInitializer(factory2, variableName, initializer) {
+  return factory2.createAssignment(
     variableName,
-    factory.createObjectLiteralExpression([
-      factory.createPropertyAssignment("value", initializer || factory.createVoidZero())
+    factory2.createObjectLiteralExpression([
+      factory2.createPropertyAssignment("value", initializer || factory2.createVoidZero())
     ])
   );
 }
-function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(weakMapName, "set"),
+function createPrivateInstanceFieldInitializer(factory2, receiver, initializer, weakMapName) {
+  return factory2.createCallExpression(
+    factory2.createPropertyAccessExpression(weakMapName, "set"),
     /*typeArguments*/
     void 0,
-    [receiver, initializer || factory.createVoidZero()]
+    [receiver, initializer || factory2.createVoidZero()]
   );
 }
-function createPrivateInstanceMethodInitializer(receiver, weakSetName) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(weakSetName, "add"),
+function createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName) {
+  return factory2.createCallExpression(
+    factory2.createPropertyAccessExpression(weakSetName, "add"),
     /*typeArguments*/
     void 0,
     [receiver]
@@ -94219,6 +94278,7 @@ function isPrivateIdentifierInExpression(node) {
 // src/compiler/transformers/typeSerializer.ts
 function createRuntimeTypeSerializer(context) {
   const {
+    factory: factory2,
     hoistVariableDeclaration
   } = context;
   const resolver = context.getEmitResolver();
@@ -94258,9 +94318,9 @@ function createRuntimeTypeSerializer(context) {
       case 260 /* ClassDeclaration */:
       case 228 /* ClassExpression */:
       case 171 /* MethodDeclaration */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       default:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
     }
   }
   function serializeParameterTypesOfNode(node, container) {
@@ -94281,7 +94341,7 @@ function createRuntimeTypeSerializer(context) {
         }
       }
     }
-    return factory.createArrayLiteralExpression(expressions);
+    return factory2.createArrayLiteralExpression(expressions);
   }
   function getParametersOfDecoratedDeclaration(node, container) {
     if (container && node.kind === 174 /* GetAccessor */) {
@@ -94296,39 +94356,39 @@ function createRuntimeTypeSerializer(context) {
     if (isFunctionLike(node) && node.type) {
       return serializeTypeNode(node.type);
     } else if (isAsyncFunction(node)) {
-      return factory.createIdentifier("Promise");
+      return factory2.createIdentifier("Promise");
     }
-    return factory.createVoidZero();
+    return factory2.createVoidZero();
   }
   function serializeTypeNode(node) {
     if (node === void 0) {
-      return factory.createIdentifier("Object");
+      return factory2.createIdentifier("Object");
     }
     node = skipTypeParentheses(node);
     switch (node.kind) {
       case 114 /* VoidKeyword */:
       case 155 /* UndefinedKeyword */:
       case 144 /* NeverKeyword */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       case 181 /* FunctionType */:
       case 182 /* ConstructorType */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       case 185 /* ArrayType */:
       case 186 /* TupleType */:
-        return factory.createIdentifier("Array");
+        return factory2.createIdentifier("Array");
       case 179 /* TypePredicate */:
-        return node.assertsModifier ? factory.createVoidZero() : factory.createIdentifier("Boolean");
+        return node.assertsModifier ? factory2.createVoidZero() : factory2.createIdentifier("Boolean");
       case 134 /* BooleanKeyword */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 200 /* TemplateLiteralType */:
       case 152 /* StringKeyword */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 149 /* ObjectKeyword */:
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       case 198 /* LiteralType */:
         return serializeLiteralOfLiteralTypeNode(node.literal);
       case 148 /* NumberKeyword */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 160 /* BigIntKeyword */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 153 /* SymbolKeyword */:
@@ -94380,13 +94440,13 @@ function createRuntimeTypeSerializer(context) {
       default:
         return Debug.failBadSyntaxKind(node);
     }
-    return factory.createIdentifier("Object");
+    return factory2.createIdentifier("Object");
   }
   function serializeLiteralOfLiteralTypeNode(node) {
     switch (node.kind) {
       case 10 /* StringLiteral */:
       case 14 /* NoSubstitutionTemplateLiteral */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 221 /* PrefixUnaryExpression */: {
         const operand = node.operand;
         switch (operand.kind) {
@@ -94398,14 +94458,14 @@ function createRuntimeTypeSerializer(context) {
         }
       }
       case 8 /* NumericLiteral */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 9 /* BigIntLiteral */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 110 /* TrueKeyword */:
       case 95 /* FalseKeyword */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 104 /* NullKeyword */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       default:
         return Debug.failBadSyntaxKind(node);
     }
@@ -94416,16 +94476,16 @@ function createRuntimeTypeSerializer(context) {
       typeNode = skipTypeParentheses(typeNode);
       if (typeNode.kind === 144 /* NeverKeyword */) {
         if (isIntersection)
-          return factory.createVoidZero();
+          return factory2.createVoidZero();
         continue;
       }
       if (typeNode.kind === 157 /* UnknownKeyword */) {
         if (!isIntersection)
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         continue;
       }
       if (typeNode.kind === 131 /* AnyKeyword */) {
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       }
       if (!strictNullChecks && (isLiteralTypeNode(typeNode) && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
         continue;
@@ -94436,13 +94496,13 @@ function createRuntimeTypeSerializer(context) {
       }
       if (serializedType) {
         if (!equateSerializedTypeNodes(serializedType, serializedConstituent)) {
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         }
       } else {
         serializedType = serializedConstituent;
       }
     }
-    return serializedType != null ? serializedType : factory.createVoidZero();
+    return serializedType != null ? serializedType : factory2.createVoidZero();
   }
   function equateSerializedTypeNodes(left, right) {
     return (
@@ -94476,48 +94536,48 @@ function createRuntimeTypeSerializer(context) {
     switch (kind) {
       case 0 /* Unknown */:
         if (findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n))) {
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         }
         const serialized = serializeEntityNameAsExpressionFallback(node.typeName);
-        const temp = factory.createTempVariable(hoistVariableDeclaration);
-        return factory.createConditionalExpression(
-          factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"),
+        const temp = factory2.createTempVariable(hoistVariableDeclaration);
+        return factory2.createConditionalExpression(
+          factory2.createTypeCheck(factory2.createAssignment(temp, serialized), "function"),
           /*questionToken*/
           void 0,
           temp,
           /*colonToken*/
           void 0,
-          factory.createIdentifier("Object")
+          factory2.createIdentifier("Object")
         );
       case 1 /* TypeWithConstructSignatureAndValue */:
         return serializeEntityNameAsExpression(node.typeName);
       case 2 /* VoidNullableOrNeverType */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       case 4 /* BigIntLikeType */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 6 /* BooleanType */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 3 /* NumberLikeType */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 5 /* StringLikeType */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 7 /* ArrayLikeType */:
-        return factory.createIdentifier("Array");
+        return factory2.createIdentifier("Array");
       case 8 /* ESSymbolType */:
         return getGlobalConstructor("Symbol", 2 /* ES2015 */);
       case 10 /* TypeWithCallSignature */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       case 9 /* Promise */:
-        return factory.createIdentifier("Promise");
+        return factory2.createIdentifier("Promise");
       case 11 /* ObjectType */:
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       default:
         return Debug.assertNever(kind);
     }
   }
   function createCheckedValue(left, right) {
-    return factory.createLogicalAnd(
-      factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")),
+    return factory2.createLogicalAnd(
+      factory2.createStrictInequality(factory2.createTypeOfExpression(left), factory2.createStringLiteral("undefined")),
       right
     );
   }
@@ -94530,13 +94590,13 @@ function createRuntimeTypeSerializer(context) {
       return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node));
     }
     const left = serializeEntityNameAsExpressionFallback(node.left);
-    const temp = factory.createTempVariable(hoistVariableDeclaration);
-    return factory.createLogicalAnd(
-      factory.createLogicalAnd(
+    const temp = factory2.createTempVariable(hoistVariableDeclaration);
+    return factory2.createLogicalAnd(
+      factory2.createLogicalAnd(
         left.left,
-        factory.createStrictInequality(factory.createAssignment(temp, left.right), factory.createVoidZero())
+        factory2.createStrictInequality(factory2.createAssignment(temp, left.right), factory2.createVoidZero())
       ),
-      factory.createPropertyAccessExpression(temp, node.right)
+      factory2.createPropertyAccessExpression(temp, node.right)
     );
   }
   function serializeEntityNameAsExpression(node) {
@@ -94551,21 +94611,21 @@ function createRuntimeTypeSerializer(context) {
     }
   }
   function serializeQualifiedNameAsExpression(node) {
-    return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
+    return factory2.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
   }
   function getGlobalConstructorWithFallback(name) {
-    return factory.createConditionalExpression(
-      factory.createTypeCheck(factory.createIdentifier(name), "function"),
+    return factory2.createConditionalExpression(
+      factory2.createTypeCheck(factory2.createIdentifier(name), "function"),
       /*questionToken*/
       void 0,
-      factory.createIdentifier(name),
+      factory2.createIdentifier(name),
       /*colonToken*/
       void 0,
-      factory.createIdentifier("Object")
+      factory2.createIdentifier("Object")
     );
   }
   function getGlobalConstructor(name, minLanguageVersion) {
-    return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory.createIdentifier(name);
+    return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory2.createIdentifier(name);
   }
 }
 
@@ -109396,7 +109456,7 @@ function transformDeclarations(context) {
     }
     const newParam = factory2.updateParameterDeclaration(
       p,
-      maskModifiers(p, modifierMask),
+      maskModifiers(factory2, p, modifierMask),
       p.dotDotDotToken,
       filterBindingPatternInitializersAndRenamings(p.name),
       resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(57 /* QuestionToken */) : void 0,
@@ -110510,8 +110570,8 @@ function isAlwaysType(node) {
   }
   return false;
 }
-function maskModifiers(node, modifierMask, modifierAdditions) {
-  return factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
+function maskModifiers(factory2, node, modifierMask, modifierAdditions) {
+  return factory2.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
 }
 function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
   let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;
@@ -123397,7 +123457,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     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);
@@ -123408,7 +123468,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       if (dirPath) {
         scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
       }
-    }, 1 /* Recursive */);
+    }, 1 /* Recursive */) : noopFileWatcher;
   }
   function updateTypeRootsWatch() {
     const options = resolutionHost.getCompilationSettings();
@@ -123416,7 +123476,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       closeTypeRootsWatch();
       return;
     }
-    const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
+    const typeRoots = getEffectiveTypeRoots(options, { getCurrentDirectory });
     if (typeRoots) {
       mutateMap(
         typeRootsWatches,
@@ -123430,7 +123490,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       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);
@@ -133235,6 +133297,10 @@ function computeSuggestionDiagnostics(sourceFile, program, cancellationToken) {
           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));
       }
@@ -135259,7 +135325,6 @@ var invalidOperationsInSyntacticMode = [
   "getTypeDefinitionAtPosition",
   "getReferencesAtPosition",
   "findReferences",
-  "getOccurrencesAtPosition",
   "getDocumentHighlights",
   "getNavigateToItems",
   "getRenameInfo",
@@ -135682,18 +135747,6 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     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));
@@ -135886,22 +135939,22 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     }
     return [];
   }
-  function getCodeFixesAtPosition(fileName, start2, end, errorCodes63, formatOptions, preferences = emptyOptions) {
+  function getCodeFixesAtPosition(fileName, start2, end, errorCodes64, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
     const sourceFile = getValidSourceFile(fileName);
     const span = createTextSpanFromBounds(start2, 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;
@@ -136323,7 +136376,6 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     getReferencesAtPosition,
     findReferences,
     getFileReferences,
-    getOccurrencesAtPosition,
     getDocumentHighlights,
     getNameOrDottedNameSpan,
     getBreakpointStatementAtPosition,
@@ -137042,12 +137094,6 @@ var LanguageServiceShimObject = class extends ShimBase {
       () => 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})`,
@@ -138656,6 +138702,7 @@ __export(ts_codefix_exports, {
   getFixes: () => getFixes,
   getImportCompletionAction: () => getImportCompletionAction,
   getImportKind: () => getImportKind,
+  getJSDocTypedefNode: () => getJSDocTypedefNode,
   getNoopSymbolTrackerWithResolver: () => getNoopSymbolTrackerWithResolver,
   getPromoteTypeOnlyCompletionAction: () => getPromoteTypeOnlyCompletionAction,
   getSupportedErrorCodes: () => getSupportedErrorCodes,
@@ -138685,23 +138732,23 @@ function createCodeFixActionWithoutFixAll(fixName8, changes, description2) {
     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);
     }
   }
 }
@@ -138709,17 +138756,17 @@ function getSupportedErrorCodes() {
   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) {
@@ -138736,14 +138783,14 @@ function createCombinedCodeActions(changes, commands) {
 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);
     }
   }
@@ -141198,61 +141245,268 @@ function getTypeExportSpecifiers(originExportSpecifier, context) {
 }
 
 // src/services/codefixes/convertToTypeOnlyImport.ts
-var errorCodes14 = [Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code];
+var 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
+];
 var 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);
+      }
     });
   }
 });
-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 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);
+    }
+  }
+}
+
+// src/services/codefixes/convertTypedefToType.ts
+var fixId14 = "convertTypedefToType";
+var 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);
+  })
+});
+function doChange5(changes, node, sourceFile) {
+  if (isJSDocTypedefTag(node)) {
+    fixSingleTypeDef(changes, node, sourceFile);
+  }
 }
-function fixSingleImportDeclaration(changes, importDeclaration, context) {
-  if (!(importDeclaration == null ? void 0 : importDeclaration.importClause)) {
+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);
   }
-  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
-    ));
+  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;
 }
 
 // src/services/codefixes/convertLiteralTypeToMappedType.ts
-var fixId14 = "convertLiteralTypeToMappedType";
-var 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];
+var fixId15 = "convertLiteralTypeToMappedType";
+var 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);
@@ -141260,14 +141514,14 @@ registerCodeFix({
       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);
     }
   })
 });
@@ -141285,7 +141539,7 @@ function getInfo2(sourceFile, pos) {
   }
   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,
@@ -141306,25 +141560,25 @@ function doChange4(changes, sourceFile, { container, typeNode, constraint, name
 }
 
 // src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
-var errorCodes16 = [
+var 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
 ];
-var fixId15 = "fixClassIncorrectlyImplementsInterface";
+var 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)) {
@@ -141389,7 +141643,7 @@ function getHeritageClauseSymbolTable(classDeclaration, checker) {
 // src/services/codefixes/importFixes.ts
 var importFixName = "import";
 var importFixId = "fixMissingImport";
-var errorCodes17 = [
+var 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,
@@ -141401,7 +141655,7 @@ var errorCodes17 = [
   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(
@@ -141436,7 +141690,7 @@ registerCodeFix({
       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));
   }
 });
@@ -142602,8 +142856,8 @@ function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitali
 }
 
 // src/services/codefixes/fixAddMissingConstraint.ts
-var fixId16 = "addMissingConstraint";
-var errorCodes18 = [
+var fixId17 = "addMissingConstraint";
+var 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,
@@ -142616,21 +142870,21 @@ var errorCodes18 = [
   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))) {
@@ -142714,7 +142968,7 @@ function tryGetConstraintType(checker, node) {
 var fixName = "fixOverrideModifier";
 var fixAddOverrideId = "fixAddOverrideModifier";
 var fixRemoveOverrideId = "fixRemoveOverrideModifier";
-var errorCodes19 = [
+var 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,
@@ -142778,20 +143032,20 @@ var errorCodeFixIdMap = {
   }
 };
 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: start2 } = diag2;
     const info = errorCodeFixIdMap[code];
     if (!info || info.fixId !== context.fixId) {
@@ -142868,22 +143122,22 @@ function findContainerClassElementLike(sourceFile, pos) {
 }
 
 // src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts
-var fixId17 = "fixNoPropertyAccessFromIndexSignature";
-var errorCodes20 = [
+var fixId18 = "fixNoPropertyAccessFromIndexSignature";
+var 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))
 });
-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(
@@ -142897,24 +143151,24 @@ function getPropertyAccessExpression(sourceFile, pos) {
 }
 
 // src/services/codefixes/fixImplicitThis.ts
-var fixId18 = "fixImplicitThis";
-var errorCodes21 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
+var fixId19 = "fixImplicitThis";
+var 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());
   })
 });
-function doChange6(changes, sourceFile, pos, checker) {
+function doChange8(changes, sourceFile, pos, checker) {
   const token = getTokenAtPosition(sourceFile, pos);
   if (!isThis(token))
     return void 0;
@@ -142957,26 +143211,26 @@ function doChange6(changes, sourceFile, pos, checker) {
 }
 
 // src/services/codefixes/fixImportNonExportedMember.ts
-var fixId19 = "fixImportNonExportedMember";
-var errorCodes22 = [
+var fixId20 = "fixImportNonExportedMember";
+var 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;
@@ -143049,7 +143303,7 @@ function getInfo4(sourceFile, pos, program) {
   }
   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]);
@@ -143133,26 +143387,26 @@ function getNodeOfSymbol(symbol) {
 }
 
 // src/services/codefixes/fixIncorrectNamedTupleSyntax.ts
-var fixId20 = "fixIncorrectNamedTupleSyntax";
-var errorCodes23 = [
+var fixId21 = "fixIncorrectNamedTupleSyntax";
+var 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]
 });
 function getNamedTupleMember(sourceFile, pos) {
   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;
   }
@@ -143181,8 +143435,8 @@ function doChange8(changes, sourceFile, namedTupleMember) {
 }
 
 // src/services/codefixes/fixSpelling.ts
-var fixId21 = "fixSpelling";
-var errorCodes24 = [
+var fixId22 = "fixSpelling";
+var 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,
@@ -143199,7 +143453,7 @@ var errorCodes24 = [
   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);
@@ -143207,15 +143461,15 @@ registerCodeFix({
       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);
   })
 });
 function getInfo5(sourceFile, pos, context, errorCode) {
@@ -143267,7 +143521,7 @@ function getInfo5(sourceFile, pos, context, errorCode) {
   }
   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;
@@ -143303,17 +143557,17 @@ function getResolvedSourceFileFromImportDeclaration(sourceFile, context, importD
 }
 
 // src/services/codefixes/returnValueCorrect.ts
-var fixId22 = "returnValueCorrect";
+var fixId23 = "returnValueCorrect";
 var fixIdAddReturnStatement = "fixAddReturnStatement";
 var fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody";
 var fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen";
-var errorCodes25 = [
+var 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: start2 }, errorCode } = context;
@@ -143329,7 +143583,7 @@ registerCodeFix({
       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;
@@ -143537,7 +143791,7 @@ function wrapBlockWithParen(changes, sourceFile, declaration, expression) {
 }
 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(
@@ -143549,11 +143803,11 @@ function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration,
     /* 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);
 }
 
 // src/services/codefixes/fixAddMissingMember.ts
@@ -143561,7 +143815,7 @@ var fixMissingMember = "fixMissingMember";
 var fixMissingProperties = "fixMissingProperties";
 var fixMissingAttributes = "fixMissingAttributes";
 var fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration";
-var errorCodes26 = [
+var 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,
@@ -143571,7 +143825,7 @@ var errorCodes26 = [
   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);
@@ -143598,21 +143852,21 @@ registerCodeFix({
   },
   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 */) {
@@ -144184,17 +144438,17 @@ function findScope(node) {
 }
 
 // src/services/codefixes/fixAddMissingNewOperator.ts
-var fixId23 = "addMissingNewOperator";
-var errorCodes27 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
+var fixId24 = "addMissingNewOperator";
+var 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))
 });
 function addMissingNewOperator(changes, sourceFile, span) {
   const call = cast(findAncestorMatchingSpan2(sourceFile, span), isCallExpression);
@@ -144214,12 +144468,12 @@ function findAncestorMatchingSpan2(sourceFile, span) {
 var fixName2 = "fixCannotFindModule";
 var fixIdInstallTypesPackage = "installTypesPackage";
 var errorCodeCannotFindModule = Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations.code;
-var errorCodes28 = [
+var 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: start2 } } = context;
     const packageName = tryGetImportedPackageName(sourceFile, start2);
@@ -144238,7 +144492,7 @@ registerCodeFix({
   },
   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;
@@ -144273,22 +144527,22 @@ function getTypesPackageNameToInstall(packageName, host, diagCode) {
 }
 
 // src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
-var errorCodes29 = [
+var 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
 ];
-var fixId24 = "fixClassDoesntImplementInheritedAbstractMember";
+var 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);
@@ -144315,35 +144569,35 @@ function symbolPointsToNonPrivateAndAbstractMember(symbol) {
 }
 
 // src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts
-var fixId25 = "classSuperMustPrecedeThisAccess";
-var errorCodes30 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code];
+var fixId26 = "classSuperMustPrecedeThisAccess";
+var 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);
       }
     });
   }
 });
-function doChange10(changes, sourceFile, constructor, superCall) {
+function doChange12(changes, sourceFile, constructor, superCall) {
   changes.insertNodeAtConstructorStart(sourceFile, constructor, superCall);
   changes.delete(sourceFile, superCall);
 }
@@ -144360,25 +144614,25 @@ function findSuperCall(n) {
 }
 
 // src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts
-var fixId26 = "constructorForDerivedNeedSuperCall";
-var errorCodes31 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code];
+var fixId27 = "constructorForDerivedNeedSuperCall";
+var 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)))
 });
 function getNode(sourceFile, pos) {
   const token = getTokenAtPosition(sourceFile, pos);
   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*/
@@ -144391,9 +144645,9 @@ function doChange11(changes, sourceFile, ctr) {
 
 // src/services/codefixes/fixEnableJsxFlag.ts
 var fixID = "fixEnableJsxFlag";
-var errorCodes32 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code];
+var 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) {
@@ -144401,47 +144655,47 @@ registerCodeFix({
     }
     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);
   })
 });
-function doChange12(changeTracker, configFile) {
+function doChange14(changeTracker, configFile) {
   setJsonCompilerOptionValue(changeTracker, configFile, "jsx", factory.createStringLiteral("react"));
 }
 
 // src/services/codefixes/fixNaNEquality.ts
-var fixId27 = "fixNaNEquality";
-var errorCodes33 = [
+var fixId28 = "fixNaNEquality";
+var 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);
       }
     });
   }
@@ -144461,7 +144715,7 @@ function getInfo8(program, sourceFile, span) {
   }
   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*/
@@ -144521,22 +144775,22 @@ registerCodeFix({
 });
 
 // src/services/codefixes/fixPropertyAssignment.ts
-var fixId28 = "fixPropertyAssignment";
-var errorCodes34 = [
+var fixId29 = "fixPropertyAssignment";
+var 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)))
 });
-function doChange14(changes, sourceFile, node) {
+function doChange16(changes, sourceFile, node) {
   changes.replaceNode(sourceFile, node, factory.createPropertyAssignment(node.name, node.objectAssignmentInitializer));
 }
 function getProperty2(sourceFile, pos) {
@@ -144544,10 +144798,10 @@ function getProperty2(sourceFile, pos) {
 }
 
 // src/services/codefixes/fixExtendsInterfaceBecomesImplements.ts
-var fixId29 = "extendsInterfaceBecomesImplements";
-var errorCodes35 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code];
+var fixId30 = "extendsInterfaceBecomesImplements";
+var 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);
@@ -144555,10 +144809,10 @@ registerCodeFix({
       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);
@@ -144586,29 +144840,29 @@ function doChanges2(changes, sourceFile, extendsToken, heritageClauses) {
 }
 
 // src/services/codefixes/fixForgottenThisPropertyAccess.ts
-var fixId30 = "forgottenThisPropertyAccess";
+var fixId31 = "forgottenThisPropertyAccess";
 var didYouMeanStaticMemberCode = Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code;
-var errorCodes36 = [
+var 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);
   })
 });
 function getInfo9(sourceFile, pos, diagCode) {
@@ -144617,7 +144871,7 @@ function getInfo9(sourceFile, pos, diagCode) {
     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));
 }
@@ -144625,16 +144879,16 @@ function doChange15(changes, sourceFile, { node, className }) {
 // src/services/codefixes/fixInvalidJsxCharacters.ts
 var fixIdExpression = "fixInvalidJsxCharacters_expression";
 var fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity";
-var errorCodes37 = [
+var 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,
@@ -144642,7 +144896,7 @@ registerCodeFix({
       /* 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,
@@ -144656,7 +144910,7 @@ registerCodeFix({
     ];
   },
   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));
   }
 });
 var htmlEntity = {
@@ -144666,7 +144920,7 @@ var htmlEntity = {
 function isValidCharacter(character) {
   return hasProperty(htmlEntity, character);
 }
-function doChange16(changes, preferences, sourceFile, start2, useHtmlEntity) {
+function doChange18(changes, preferences, sourceFile, start2, useHtmlEntity) {
   const character = sourceFile.getText()[start2];
   if (!isValidCharacter(character)) {
     return;
@@ -144678,12 +144932,12 @@ function doChange16(changes, preferences, sourceFile, start2, useHtmlEntity) {
 // src/services/codefixes/fixUnmatchedParameter.ts
 var deleteUnmatchedParameter = "deleteUnmatchedParameter";
 var renameUnmatchedParameter = "renameUnmatchedParameter";
-var errorCodes38 = [
+var 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 = [];
@@ -144698,7 +144952,7 @@ registerCodeFix({
   getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) {
     const tagsToSignature = /* @__PURE__ */ new Map();
     return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-      eachDiagnostic(context, errorCodes38, ({ file, start: start2 }) => {
+      eachDiagnostic(context, errorCodes39, ({ file, start: start2 }) => {
         const info = getInfo10(file, start2);
         if (info) {
           tagsToSignature.set(info.signature, append(tagsToSignature.get(info.signature), info.jsDocParameterTag));
@@ -144763,10 +145017,10 @@ function getInfo10(sourceFile, pos) {
 }
 
 // src/services/codefixes/fixUnreferenceableDecoratorMetadata.ts
-var fixId31 = "fixUnreferenceableDecoratorMetadata";
-var 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];
+var fixId32 = "fixUnreferenceableDecoratorMetadata";
+var 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)
@@ -144775,14 +145029,14 @@ registerCodeFix({
     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]
 });
 function getImportDeclaration(sourceFile, program, start2) {
   const identifier = tryCast(getTokenAtPosition(sourceFile, start2), isIdentifier);
@@ -144821,7 +145075,7 @@ var fixIdPrefix = "unusedIdentifier_prefix";
 var fixIdDelete = "unusedIdentifier_delete";
 var fixIdDeleteImports = "unusedIdentifier_deleteImports";
 var fixIdInfer = "unusedIdentifier_infer";
-var errorCodes40 = [
+var 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,
@@ -144831,7 +145085,7 @@ var errorCodes40 = [
   Diagnostics.All_type_parameters_are_unused.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes40,
+  errorCodes: errorCodes41,
   getCodeActions(context) {
     const { errorCode, sourceFile, program, cancellationToken } = context;
     const checker = program.getTypeChecker();
@@ -144917,7 +145171,7 @@ registerCodeFix({
     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:
@@ -145134,21 +145388,21 @@ function mayDeleteExpression(node) {
 }
 
 // src/services/codefixes/fixUnreachableCode.ts
-var fixId32 = "fixUnreachableCode";
-var errorCodes41 = [Diagnostics.Unreachable_code_detected.code];
+var fixId33 = "fixUnreachableCode";
+var 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))
 });
-function doChange17(changes, sourceFile, start2, length2, errorCode) {
+function doChange19(changes, sourceFile, start2, length2, errorCode) {
   const token = getTokenAtPosition(sourceFile, start2);
   const statement = findAncestor(token, isStatement);
   if (statement.getStart(sourceFile) !== token.getStart(sourceFile)) {
@@ -145198,18 +145452,18 @@ function lastWhere(a, pred) {
 }
 
 // src/services/codefixes/fixUnusedLabel.ts
-var fixId33 = "fixUnusedLabel";
-var errorCodes42 = [Diagnostics.Unused_label.code];
+var fixId34 = "fixUnusedLabel";
+var 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))
 });
-function doChange18(changes, sourceFile, start2) {
+function doChange20(changes, sourceFile, start2) {
   const token = getTokenAtPosition(sourceFile, start2);
   const labeledStatement = cast(token.parent, isLabeledStatement);
   const pos = token.getStart(sourceFile);
@@ -145226,13 +145480,13 @@ function doChange18(changes, sourceFile, start2) {
 // src/services/codefixes/fixJSDocTypes.ts
 var fixIdPlain = "fixJSDocTypes_plain";
 var fixIdNullable = "fixJSDocTypes_nullable";
-var errorCodes43 = [
+var 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();
@@ -145246,26 +145500,26 @@ registerCodeFix({
       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);
     });
   }
 });
-function doChange19(changes, sourceFile, oldTypeNode, newType, checker) {
+function doChange21(changes, sourceFile, oldTypeNode, newType, checker) {
   changes.replaceNode(sourceFile, oldTypeNode, checker.typeToTypeNode(
     newType,
     /*enclosingDeclaration*/
@@ -145316,28 +145570,28 @@ function getType(checker, node) {
 }
 
 // src/services/codefixes/fixMissingCallParentheses.ts
-var fixId34 = "fixMissingCallParentheses";
-var errorCodes44 = [
+var fixId35 = "fixMissingCallParentheses";
+var 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);
   })
 });
-function doChange20(changes, sourceFile, name) {
+function doChange22(changes, sourceFile, name) {
   changes.replaceNodeWithText(sourceFile, name, `${name.text}()`);
 }
 function getCallName(sourceFile, start2) {
@@ -145356,30 +145610,30 @@ function getCallName(sourceFile, start2) {
 }
 
 // src/services/codefixes/fixAwaitInSyncFunction.ts
-var fixId35 = "fixAwaitInSyncFunction";
-var errorCodes45 = [
+var fixId36 = "fixAwaitInSyncFunction";
+var 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);
     });
   }
 });
@@ -145418,7 +145672,7 @@ function getNodes3(sourceFile, start2) {
     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") {
@@ -145429,22 +145683,22 @@ function doChange21(changes, sourceFile, { insertBefore, returnType }) {
 }
 
 // src/services/codefixes/fixPropertyOverrideAccessor.ts
-var errorCodes46 = [
+var 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
 ];
-var fixId36 = "fixPropertyOverrideAccessor";
+var 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);
@@ -145452,7 +145706,7 @@ registerCodeFix({
     }
   })
 });
-function doChange22(file, start2, length2, code, context) {
+function doChange24(file, start2, 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) {
@@ -145481,8 +145735,8 @@ function doChange22(file, start2, length2, code, context) {
 }
 
 // src/services/codefixes/inferFromUsage.ts
-var fixId37 = "inferFromUsage";
-var errorCodes47 = [
+var fixId38 = "inferFromUsage";
+var errorCodes48 = [
   // Variable declarations
   Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code,
   // Variable uses
@@ -145516,13 +145770,13 @@ var errorCodes47 = [
   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: start2 }, errorCode, cancellationToken, host, preferences } = context;
     const token = getTokenAtPosition(sourceFile, start2);
     let declaration;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
-      declaration = doChange23(
+      declaration = doChange25(
         changes2,
         sourceFile,
         token,
@@ -145536,14 +145790,14 @@ registerCodeFix({
       );
     });
     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);
     });
   }
 });
@@ -145582,7 +145836,7 @@ function mapSuggestionDiagnostic(errorCode) {
   }
   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;
   }
@@ -146246,7 +146500,7 @@ function inferTypeFromReferences(program, references, cancellationToken) {
     const props = createMultiMap();
     for (const anon2 of anons) {
       for (const p of checker.getPropertiesOfType(anon2)) {
-        props.add(p.name, p.valueDeclaration ? checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration) : checker.getAnyType());
+        props.add(p.escapedName, p.valueDeclaration ? checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration) : checker.getAnyType());
       }
       calls.push(...checker.getSignaturesOfType(anon2, 0 /* Call */));
       constructs.push(...checker.getSignaturesOfType(anon2, 1 /* Construct */));
@@ -146478,13 +146732,13 @@ function inferTypeFromReferences(program, references, cancellationToken) {
 }
 
 // src/services/codefixes/fixReturnTypeInAsyncFunction.ts
-var fixId38 = "fixReturnTypeInAsyncFunction";
-var errorCodes48 = [
+var fixId39 = "fixReturnTypeInAsyncFunction";
+var 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();
@@ -146493,23 +146747,23 @@ registerCodeFix({
       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);
     }
   })
 });
@@ -146536,19 +146790,19 @@ function getInfo12(sourceFile, checker, pos) {
     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]));
 }
 
 // src/services/codefixes/disableJsDiagnostics.ts
 var fixName4 = "disableJsDiagnostics";
-var fixId39 = "disableJsDiagnostics";
-var errorCodes49 = mapDefined(Object.keys(Diagnostics), (key) => {
+var fixId40 = "disableJsDiagnostics";
+var 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())) {
@@ -146566,14 +146820,14 @@ registerCodeFix({
       )
     ];
     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);
       }
@@ -147553,9 +147807,9 @@ var fixName6 = "strictClassInitialization";
 var fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions";
 var fixIdAddUndefinedType = "addMissingPropertyUndefinedType";
 var fixIdAddInitializer = "addMissingPropertyInitializer";
-var errorCodes50 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
+var 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)
@@ -147568,7 +147822,7 @@ registerCodeFix({
   },
   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;
@@ -147698,27 +147952,27 @@ function getDefaultValueFromType(checker, type) {
 }
 
 // src/services/codefixes/requireInTs.ts
-var fixId40 = "requireInTs";
-var errorCodes51 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
+var fixId41 = "requireInTs";
+var 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);
     }
   })
 });
-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*/
@@ -147782,23 +148036,23 @@ function tryCreateNamedImportsFromObjectBindingPattern(node) {
 }
 
 // src/services/codefixes/useDefaultImport.ts
-var fixId41 = "useDefaultImport";
-var errorCodes52 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
+var fixId42 = "useDefaultImport";
+var errorCodes53 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
 registerCodeFix({
-  errorCodes: errorCodes52,
+  errorCodes: errorCodes53,
   getCodeActions(context) {
     const { sourceFile, span: { start: start2 } } = context;
     const info = getInfo15(sourceFile, start2);
     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);
   })
 });
 function getInfo15(sourceFile, pos) {
@@ -147813,7 +148067,7 @@ function getInfo15(sourceFile, pos) {
     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*/
@@ -147824,21 +148078,21 @@ function doChange26(changes, sourceFile, info, preferences) {
 }
 
 // src/services/codefixes/useBigintLiteral.ts
-var fixId42 = "useBigintLiteral";
-var errorCodes53 = [
+var fixId43 = "useBigintLiteral";
+var 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));
   }
 });
 function makeChange9(changeTracker, sourceFile, span) {
@@ -147852,18 +148106,18 @@ function makeChange9(changeTracker, sourceFile, span) {
 
 // src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts
 var fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof";
-var fixId43 = fixIdAddMissingTypeof;
-var errorCodes54 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
+var fixId44 = fixIdAddMissingTypeof;
+var 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)))
 });
 function getImportTypeNode(sourceFile, pos) {
   const token = getTokenAtPosition(sourceFile, pos);
@@ -147871,7 +148125,7 @@ function getImportTypeNode(sourceFile, pos) {
   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,
@@ -147886,23 +148140,23 @@ function doChange27(changes, sourceFile, importType) {
 
 // src/services/codefixes/wrapJsxInFragment.ts
 var fixID2 = "wrapJsxInFragment";
-var errorCodes55 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
+var 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);
   })
 });
 function findNodeToFix(sourceFile, pos) {
@@ -147918,7 +148172,7 @@ function findNodeToFix(sourceFile, pos) {
     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()));
@@ -147943,24 +148197,24 @@ function flattenInvalidBinaryExpr(node) {
 }
 
 // src/services/codefixes/convertToMappedObjectType.ts
-var fixId44 = "fixConvertToMappedObjectType";
-var errorCodes56 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
+var fixId45 = "fixConvertToMappedObjectType";
+var 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);
   })
 });
 function getInfo16(sourceFile, pos) {
@@ -147976,7 +148230,7 @@ function getInfo16(sourceFile, pos) {
 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);
@@ -148005,12 +148259,12 @@ function doChange29(changes, sourceFile, { indexSignature, container }) {
 }
 
 // src/services/codefixes/removeAccidentalCallParentheses.ts
-var fixId45 = "removeAccidentalCallParentheses";
-var errorCodes57 = [
+var fixId46 = "removeAccidentalCallParentheses";
+var 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) {
@@ -148019,27 +148273,27 @@ registerCodeFix({
     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]
 });
 
 // src/services/codefixes/removeUnnecessaryAwait.ts
-var fixId46 = "removeUnnecessaryAwait";
-var errorCodes58 = [
+var fixId47 = "removeUnnecessaryAwait";
+var 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));
   }
 });
 function makeChange10(changeTracker, sourceFile, span) {
@@ -148067,20 +148321,20 @@ function makeChange10(changeTracker, sourceFile, span) {
 }
 
 // src/services/codefixes/splitTypeOnlyImport.ts
-var errorCodes59 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
-var fixId47 = "splitTypeOnlyImport";
+var errorCodes60 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
+var 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);
   })
 });
@@ -148121,34 +148375,34 @@ function splitTypeOnlyImport(changes, importDeclaration, context) {
 }
 
 // src/services/codefixes/convertConstToLet.ts
-var fixId48 = "fixConvertConstToLet";
-var errorCodes60 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
+var fixId49 = "fixConvertConstToLet";
+var 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]
 });
 function getInfo17(sourceFile, pos, program) {
   var _a2;
@@ -148164,64 +148418,64 @@ function getInfo17(sourceFile, pos, program) {
     return;
   return { symbol, token: constToken };
 }
-function doChange30(changes, sourceFile, token) {
+function doChange32(changes, sourceFile, token) {
   changes.replaceNode(sourceFile, token, factory.createToken(119 /* LetKeyword */));
 }
 
 // src/services/codefixes/fixExpectedComma.ts
-var fixId49 = "fixExpectedComma";
+var fixId50 = "fixExpectedComma";
 var expectedErrorCode = Diagnostics._0_expected.code;
-var errorCodes61 = [expectedErrorCode];
+var 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);
   })
 });
 function getInfo18(sourceFile, pos, _) {
   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);
 }
 
 // src/services/codefixes/fixAddVoidToPromise.ts
 var fixName7 = "addVoidToPromise";
-var fixId50 = "addVoidToPromise";
-var errorCodes62 = [
+var fixId51 = "addVoidToPromise";
+var 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()));
   }
 });
 function makeChange11(changes, sourceFile, span, program, seen) {
@@ -150110,7 +150364,8 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   }
   log("getCompletionData: Semantic work: " + (timestamp() - semanticStart));
   const contextualType = previousToken && getContextualType(previousToken, position, sourceFile, typeChecker);
-  const literals = mapDefined(
+  const isLiteralExpected = !tryCast(previousToken, isStringLiteralLike) && !isJsxIdentifierExpected;
+  const literals = !isLiteralExpected ? [] : mapDefined(
     contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]),
     (t) => t.isLiteral() && !(t.flags & 1024 /* EnumLiteral */) ? t.value : void 0
   );
@@ -156578,8 +156833,7 @@ function compareModuleSpecifiers2(m1, m2, ignoreCase) {
 function compareModuleSpecifiersWorker(m1, m2, comparer) {
   const name1 = m1 === void 0 ? void 0 : getExternalModuleName2(m1);
   const name2 = m2 === void 0 ? void 0 : getExternalModuleName2(m2);
-  return compareBooleans(name1 === void 0, name2 === void 0) || compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) || // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-  comparer(name1, name2);
+  return compareBooleans(name1 === void 0, name2 === void 0) || compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) || comparer(name1, name2);
 }
 function getModuleSpecifierExpression(declaration) {
   var _a2;
@@ -157256,7 +157510,7 @@ registerRefactor(refactorName, {
     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 };
   }
 });
@@ -157309,7 +157563,7 @@ function getInfo19(context, considerPartialSpans = true) {
       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);
 }
@@ -157504,7 +157758,7 @@ registerRefactor(refactorName2, {
     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 };
   }
 });
@@ -157535,7 +157789,7 @@ function getImportConversionInfo(context, considerPartialSpans = true) {
 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()));
@@ -158008,7 +158262,7 @@ registerRefactor(refactorName4, {
   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 };
   }
 });
@@ -158033,7 +158287,7 @@ function getRangeToMove(context) {
     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);
@@ -159405,12 +159659,12 @@ function getRefactorEditsToConvertParametersToDestructuredObject(context, action
     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) {
@@ -160174,7 +160428,7 @@ function getRefactorEditsToConvertToOptionalChain(context, actionName2) {
   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 };
 }
@@ -160330,7 +160584,7 @@ function convertOccurrences(checker, toConvert, occurrences) {
   }
   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);
@@ -162025,7 +162279,7 @@ registerRefactor(refactorName12, {
 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;
@@ -162050,7 +162304,7 @@ function getRefactorActionsToInferReturnType(context) {
   }
   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;
@@ -168103,7 +168357,6 @@ __export(ts_exports3, {
   createTypeChecker: () => createTypeChecker,
   createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
   createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
-  createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
   createUnparsedSourceFile: () => createUnparsedSourceFile,
   createWatchCompilerHost: () => createWatchCompilerHost2,
   createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,
@@ -169514,7 +169767,6 @@ __export(ts_exports3, {
   nodeToDisplayParts: () => nodeToDisplayParts,
   noop: () => noop,
   noopFileWatcher: () => noopFileWatcher,
-  noopPush: () => noopPush,
   normalizePath: () => normalizePath,
   normalizeSlashes: () => normalizeSlashes,
   not: () => not,
@@ -170391,7 +170643,6 @@ var CommandTypes = /* @__PURE__ */ ((CommandTypes2) => {
   CommandTypes2["NavtoFull"] = "navto-full";
   CommandTypes2["NavTree"] = "navtree";
   CommandTypes2["NavTreeFull"] = "navtree-full";
-  CommandTypes2["Occurrences"] = "occurrences";
   CommandTypes2["DocumentHighlights"] = "documentHighlights";
   CommandTypes2["DocumentHighlightsFull"] = "documentHighlights-full";
   CommandTypes2["Open"] = "open";
@@ -170596,17 +170847,14 @@ var TextStorage = class {
      * 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();
@@ -170619,15 +170867,17 @@ var TextStorage = class {
   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(start2, end, newText) {
     this.switchToScriptVersionCache().edit(start2, end - start2, newText);
     this.ownFileText = false;
     this.text = void 0;
+    this.textSnapshot = void 0;
     this.lineMap = void 0;
     this.fileSize = void 0;
     this.resetSourceMapInfo();
@@ -170639,6 +170889,9 @@ var TextStorage = class {
   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;
@@ -170651,21 +170904,18 @@ var TextStorage = class {
    * 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;
@@ -170681,39 +170931,48 @@ var TextStorage = class {
     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 start2 = lineMap[line];
-      const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
-      return createTextSpanFromBounds(start2, end);
-    }
-    return this.svc.lineToTextSpan(line);
+    const svc = this.tryUseScriptVersionCache();
+    if (svc)
+      return svc.lineToTextSpan(line);
+    const lineMap = this.getLineMap();
+    const start2 = lineMap[line];
+    const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
+    return createTextSpanFromBounds(start2, 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;
@@ -170731,19 +170990,25 @@ var TextStorage = class {
     }
     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;
   }
@@ -170756,13 +171021,14 @@ var TextStorage = class {
   }
   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();
@@ -170786,20 +171052,11 @@ var ScriptInfo = class {
     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;
   }
@@ -170814,11 +171071,7 @@ var ScriptInfo = class {
   }
   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();
     }
   }
@@ -170998,22 +171251,12 @@ var ScriptInfo = class {
     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(start2, end, newText) {
     this.textStorage.edit(start2, end, newText);
     this.markContainingProjectsAsDirty();
@@ -171053,10 +171296,6 @@ var ScriptInfo = class {
     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);
@@ -171201,7 +171440,7 @@ function countEachFileTypes(infos, includeSizes = false) {
     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;
@@ -172185,10 +172424,26 @@ var Project3 = class {
     const elapsed = timestamp() - start2;
     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`);
@@ -172298,6 +172553,16 @@ var Project3 = class {
     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)
@@ -172307,23 +172572,33 @@ var Project3 = class {
 `;
     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
       );
     }
@@ -173347,7 +173622,7 @@ var ConfiguredProject2 = class extends Project3 {
     return !!this.externalProjectRefCount;
   }
   getEffectiveTypeRoots() {
-    return getEffectiveTypeRoots(this.getCompilationSettings(), this.directoryStructureHost) || [];
+    return getEffectiveTypeRoots(this.getCompilationSettings(), this) || [];
   }
   /** @internal */
   updateErrorOnNoInputFiles(fileNames) {
@@ -174278,7 +174553,11 @@ var _ProjectService = class {
     this.logger.info("`remove Project::");
     project.print(
       /*writeProjectFileNames*/
-      true
+      true,
+      /*writeFileExplaination*/
+      true,
+      /*writeFileVersionAndText*/
+      false
     );
     project.close();
     if (Debug.shouldAssert(1 /* Normal */)) {
@@ -174417,7 +174696,7 @@ var _ProjectService = class {
   }
   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);
@@ -175501,7 +175780,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;
@@ -176632,6 +176911,10 @@ function isConfigFile(config) {
 function printProjectWithoutFileNames(project) {
   project.print(
     /*writeProjectFileNames*/
+    false,
+    /*writeFileExplaination*/
+    false,
+    /*writeFileVersionAndText*/
     false
   );
 }
@@ -177270,7 +177553,6 @@ var invalidSyntacticModeCommands = [
   "signatureHelp-full" /* SignatureHelpFull */,
   "navto" /* Navto */,
   "navto-full" /* NavtoFull */,
-  "occurrences" /* Occurrences */,
   "documentHighlights" /* DocumentHighlights */,
   "documentHighlights-full" /* DocumentHighlightsFull */
 ];
@@ -177703,9 +177985,6 @@ var Session3 = class {
           false
         ));
       },
-      ["occurrences" /* Occurrences */]: (request) => {
-        return this.requiredResponse(this.getOccurrences(request.arguments));
-      },
       ["documentHighlights" /* DocumentHighlights */]: (request) => {
         return this.requiredResponse(this.getDocumentHighlights(
           request.arguments,
@@ -178668,21 +178947,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) {
@@ -179093,7 +179357,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;
@@ -179318,6 +179582,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
   change(args) {
     const scriptInfo = this.projectService.getScriptInfo(args.file);
     Debug.assert(!!scriptInfo);
+    scriptInfo.textStorage.switchToScriptVersionCache();
     const start2 = scriptInfo.lineOffsetToPosition(args.line, args.offset);
     const end = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset);
     if (start2 >= 0) {
@@ -179610,10 +179875,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 {
@@ -179652,8 +179917,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));
@@ -182053,7 +182318,6 @@ start(initializeNodeSystem(), require("os").platform());
   createTypeChecker,
   createTypeReferenceDirectiveResolutionCache,
   createTypeReferenceResolutionLoader,
-  createUnderscoreEscapedMultiMap,
   createUnparsedSourceFile,
   createWatchCompilerHost,
   createWatchCompilerHostOfConfigFile,
@@ -183464,7 +183728,6 @@ start(initializeNodeSystem(), require("os").platform());
   nodeToDisplayParts,
   noop,
   noopFileWatcher,
-  noopPush,
   normalizePath,
   normalizeSlashes,
   not,