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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230227`;
+      version = `${versionMajorMinor}.0-dev.20230302`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -1000,9 +1000,6 @@ var ts = (() => {
       }
     }
   }
-  function createUnderscoreEscapedMultiMap() {
-    return createMultiMap();
-  }
   function createQueue(items) {
     const elements = (items == null ? void 0 : items.slice()) || [];
     let headIndex = 0;
@@ -1625,7 +1622,7 @@ var ts = (() => {
   function isNodeLikeSystem() {
     return typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object";
   }
-  var emptyArray, emptyMap, emptySet, SortKind, elementAt, hasOwnProperty, noopPush, fileNameLowerCaseRegExp, AssertionLevel, createUIStringComparer, uiComparerCaseSensitive, uiLocale, trimString, trimStringEnd, trimStringStart;
+  var emptyArray, emptyMap, emptySet, SortKind, elementAt, hasOwnProperty, fileNameLowerCaseRegExp, AssertionLevel, createUIStringComparer, uiComparerCaseSensitive, uiLocale, trimString, trimStringEnd, trimStringStart;
   var init_core = __esm({
     "src/compiler/core.ts"() {
       "use strict";
@@ -1650,10 +1647,6 @@ var ts = (() => {
         return void 0;
       };
       hasOwnProperty = Object.prototype.hasOwnProperty;
-      noopPush = {
-        push: noop,
-        length: 0
-      };
       fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
       AssertionLevel = /* @__PURE__ */ ((AssertionLevel2) => {
         AssertionLevel2[AssertionLevel2["None"] = 0] = "None";
@@ -8461,6 +8454,7 @@ ${lanes.join("\n")}
         File_name_0_has_a_1_extension_looking_up_2_instead: diag(6262, 3 /* Message */, "File_name_0_has_a_1_extension_looking_up_2_instead_6262", "File name '{0}' has a '{1}' extension - looking up '{2}' instead."),
         Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set: diag(6263, 1 /* Error */, "Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set_6263", "Module '{0}' was resolved to '{1}', but '--allowArbitraryExtensions' is not set."),
         Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present: diag(6264, 3 /* Message */, "Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present_6264", "Enable importing files with any extension, provided a declaration file is present."),
+        Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder: diag(6265, 3 /* Message */, "Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_no_6265", "Resolving type reference directive for program that specifies custom typeRoots, skipping lookup in 'node_modules' folder."),
         Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, 3 /* Message */, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
         Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, 3 /* Message */, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
         Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, 3 /* Message */, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -8856,6 +8850,8 @@ ${lanes.join("\n")}
         This_may_be_converted_to_an_async_function: diag(80006, 2 /* Suggestion */, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."),
         await_has_no_effect_on_the_type_of_this_expression: diag(80007, 2 /* Suggestion */, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."),
         Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, 2 /* Suggestion */, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."),
+        JSDoc_typedef_may_be_converted_to_TypeScript_type: diag(80009, 2 /* Suggestion */, "JSDoc_typedef_may_be_converted_to_TypeScript_type_80009", "JSDoc typedef may be converted to TypeScript type."),
+        JSDoc_typedefs_may_be_converted_to_TypeScript_types: diag(80010, 2 /* Suggestion */, "JSDoc_typedefs_may_be_converted_to_TypeScript_types_80010", "JSDoc typedefs may be converted to TypeScript types."),
         Add_missing_super_call: diag(90001, 3 /* Message */, "Add_missing_super_call_90001", "Add missing 'super()' call"),
         Make_super_call_the_first_statement_in_the_constructor: diag(90002, 3 /* Message */, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"),
         Change_extends_to_implements: diag(90003, 3 /* Message */, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"),
@@ -9070,6 +9066,8 @@ ${lanes.join("\n")}
         Rename_param_tag_name_0_to_1: diag(95173, 3 /* Message */, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
         Use_0: diag(95174, 3 /* Message */, "Use_0_95174", "Use `{0}`."),
         Use_Number_isNaN_in_all_conditions: diag(95175, 3 /* Message */, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."),
+        Convert_typedef_to_TypeScript_type: diag(95176, 3 /* Message */, "Convert_typedef_to_TypeScript_type_95176", "Convert typedef to TypeScript type."),
+        Convert_all_typedef_to_TypeScript_types: diag(95177, 3 /* Message */, "Convert_all_typedef_to_TypeScript_types_95177", "Convert all typedef to TypeScript types."),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -38856,20 +38854,14 @@ ${lanes.join("\n")}
       currentDirectory = host.getCurrentDirectory();
     }
     if (currentDirectory !== void 0) {
-      return getDefaultTypeRoots(currentDirectory, host);
+      return getDefaultTypeRoots(currentDirectory);
     }
   }
-  function getDefaultTypeRoots(currentDirectory, host) {
-    if (!host.directoryExists) {
-      return [combinePaths(currentDirectory, nodeModulesAtTypes)];
-    }
+  function getDefaultTypeRoots(currentDirectory) {
     let typeRoots;
     forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => {
       const atTypes = combinePaths(directory, nodeModulesAtTypes);
-      if (host.directoryExists(atTypes)) {
-        (typeRoots || (typeRoots = [])).push(atTypes);
-      }
-      return void 0;
+      (typeRoots != null ? typeRoots : typeRoots = []).push(atTypes);
     });
     return typeRoots;
   }
@@ -39005,10 +38997,22 @@ ${lanes.join("\n")}
         }
         return firstDefined(typeRoots, (typeRoot) => {
           const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
-          const candidateDirectory = getDirectoryPath(candidate);
-          const directoryExists = directoryProbablyExists(candidateDirectory, host);
+          const directoryExists = directoryProbablyExists(typeRoot, host);
           if (!directoryExists && traceEnabled) {
-            trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+            trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
+          }
+          if (options.typeRoots) {
+            const resolvedFromFile = loadModuleFromFile(4 /* Declaration */, candidate, !directoryExists, moduleResolutionState);
+            if (resolvedFromFile) {
+              const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);
+              const packageInfo = packageDirectory ? getPackageJsonInfo(
+                packageDirectory,
+                /*onlyRecordFailures*/
+                false,
+                moduleResolutionState
+              ) : void 0;
+              return resolvedTypeScriptOnly(withPackageId(packageInfo, resolvedFromFile));
+            }
           }
           return resolvedTypeScriptOnly(
             loadNodeModuleFromDirectory(
@@ -39028,33 +39032,37 @@ ${lanes.join("\n")}
     function secondaryLookup() {
       const initialLocationForSecondaryLookup = containingFile && getDirectoryPath(containingFile);
       if (initialLocationForSecondaryLookup !== void 0) {
-        if (traceEnabled) {
-          trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
-        }
         let result2;
-        if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
-          const searchResult = loadModuleFromNearestNodeModulesDirectory(
-            4 /* Declaration */,
-            typeReferenceDirectiveName,
-            initialLocationForSecondaryLookup,
-            moduleResolutionState,
-            /*cache*/
-            void 0,
-            /*redirectedReference*/
-            void 0
-          );
-          result2 = searchResult && searchResult.value;
-        } else {
-          const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
-          result2 = nodeLoadModuleByRelativeName(
-            4 /* Declaration */,
-            candidate,
-            /*onlyRecordFailures*/
-            false,
-            moduleResolutionState,
-            /*considerPackageJson*/
-            true
-          );
+        if (!options.typeRoots || !endsWith(containingFile, inferredTypesContainingFile)) {
+          if (traceEnabled) {
+            trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
+          }
+          if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
+            const searchResult = loadModuleFromNearestNodeModulesDirectory(
+              4 /* Declaration */,
+              typeReferenceDirectiveName,
+              initialLocationForSecondaryLookup,
+              moduleResolutionState,
+              /*cache*/
+              void 0,
+              /*redirectedReference*/
+              void 0
+            );
+            result2 = searchResult && searchResult.value;
+          } else {
+            const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
+            result2 = nodeLoadModuleByRelativeName(
+              4 /* Declaration */,
+              candidate,
+              /*onlyRecordFailures*/
+              false,
+              moduleResolutionState,
+              /*considerPackageJson*/
+              true
+            );
+          }
+        } else if (traceEnabled) {
+          trace(host, Diagnostics.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder);
         }
         return resolvedTypeScriptOnly(result2);
       } else {
@@ -39873,6 +39881,9 @@ ${lanes.join("\n")}
           }
           resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
         }
+        if (extensions2 & 4 /* Declaration */) {
+          resolved2 != null ? resolved2 : resolved2 = resolveFromTypeRoot(moduleName, state2);
+        }
         return resolved2 && { value: resolved2.value && { resolved: resolved2.value, isExternalLibraryImport: true } };
       } else {
         const { path: candidate, parts } = normalizePathForCJSResolution(containingDirectory, moduleName);
@@ -40052,6 +40063,7 @@ ${lanes.join("\n")}
     return forEach(state.compilerOptions.moduleSuffixes, (suffix) => tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state));
   }
   function tryFileLookup(fileName, onlyRecordFailures, state) {
+    var _a2;
     if (!onlyRecordFailures) {
       if (state.host.fileExists(fileName)) {
         if (state.traceEnabled) {
@@ -40064,7 +40076,7 @@ ${lanes.join("\n")}
         }
       }
     }
-    state.failedLookupLocations.push(fileName);
+    (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(fileName);
     return void 0;
   }
   function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
@@ -40179,8 +40191,8 @@ ${lanes.join("\n")}
       host,
       compilerOptions: options,
       traceEnabled: isTraceEnabled(options, host),
-      failedLookupLocations: noopPush,
-      affectingLocations: noopPush,
+      failedLookupLocations: void 0,
+      affectingLocations: void 0,
       packageJsonInfoCache,
       features: 0 /* None */,
       conditions: emptyArray,
@@ -40214,24 +40226,24 @@ ${lanes.join("\n")}
     return packageJsonInfo.contents.versionPaths || void 0;
   }
   function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
-    var _a2, _b, _c;
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
     const { host, traceEnabled } = state;
     const packageJsonPath = combinePaths(packageDirectory, "package.json");
     if (onlyRecordFailures) {
-      state.failedLookupLocations.push(packageJsonPath);
+      (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(packageJsonPath);
       return void 0;
     }
-    const existing = (_a2 = state.packageJsonInfoCache) == null ? void 0 : _a2.getPackageJsonInfo(packageJsonPath);
+    const existing = (_b = state.packageJsonInfoCache) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
     if (existing !== void 0) {
       if (typeof existing !== "boolean") {
         if (traceEnabled)
           trace(host, Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
-        state.affectingLocations.push(packageJsonPath);
+        (_c = state.affectingLocations) == null ? void 0 : _c.push(packageJsonPath);
         return existing.packageDirectory === packageDirectory ? existing : { packageDirectory, contents: existing.contents };
       } else {
         if (existing && traceEnabled)
           trace(host, Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath);
-        state.failedLookupLocations.push(packageJsonPath);
+        (_d = state.failedLookupLocations) == null ? void 0 : _d.push(packageJsonPath);
         return void 0;
       }
     }
@@ -40242,15 +40254,15 @@ ${lanes.join("\n")}
         trace(host, Diagnostics.Found_package_json_at_0, packageJsonPath);
       }
       const result = { packageDirectory, contents: { packageJsonContent, versionPaths: void 0, resolvedEntrypoints: void 0 } };
-      (_b = state.packageJsonInfoCache) == null ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
-      state.affectingLocations.push(packageJsonPath);
+      (_e = state.packageJsonInfoCache) == null ? void 0 : _e.setPackageJsonInfo(packageJsonPath, result);
+      (_f = state.affectingLocations) == null ? void 0 : _f.push(packageJsonPath);
       return result;
     } else {
       if (directoryExists && traceEnabled) {
         trace(host, Diagnostics.File_0_does_not_exist, packageJsonPath);
       }
-      (_c = state.packageJsonInfoCache) == null ? void 0 : _c.setPackageJsonInfo(packageJsonPath, directoryExists);
-      state.failedLookupLocations.push(packageJsonPath);
+      (_g = state.packageJsonInfoCache) == null ? void 0 : _g.setPackageJsonInfo(packageJsonPath, directoryExists);
+      (_h = state.failedLookupLocations) == null ? void 0 : _h.push(packageJsonPath);
     }
   }
   function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
@@ -41070,11 +41082,13 @@ ${lanes.join("\n")}
             state
           ));
         });
-        if (resolved2) {
+        if (resolved2)
           return resolved2;
-        }
         if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
-          return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+          let resolved3 = loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
+          if (extensions & 4 /* Declaration */)
+            resolved3 != null ? resolved3 : resolved3 = resolveFromTypeRoot(moduleName, state);
+          return resolved3;
         }
       } else {
         const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
@@ -41088,6 +41102,31 @@ ${lanes.join("\n")}
       }
     }
   }
+  function resolveFromTypeRoot(moduleName, state) {
+    if (!state.compilerOptions.typeRoots)
+      return;
+    for (const typeRoot of state.compilerOptions.typeRoots) {
+      const candidate = combinePaths(typeRoot, moduleName);
+      const directoryExists = directoryProbablyExists(typeRoot, state.host);
+      if (!directoryExists && state.traceEnabled) {
+        trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
+      }
+      const resolvedFromFile = loadModuleFromFile(4 /* Declaration */, candidate, !directoryExists, state);
+      if (resolvedFromFile) {
+        const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);
+        const packageInfo = packageDirectory ? getPackageJsonInfo(
+          packageDirectory,
+          /*onlyRecordFailures*/
+          false,
+          state
+        ) : void 0;
+        return toSearchResult(withPackageId(packageInfo, resolvedFromFile));
+      }
+      const resolved = loadNodeModuleFromDirectory(4 /* Declaration */, candidate, !directoryExists, state);
+      if (resolved)
+        return toSearchResult(resolved);
+    }
+  }
   function shouldAllowImportingTsExtension(compilerOptions, fromFileName) {
     return !!compilerOptions.allowImportingTsExtensions || fromFileName && isDeclarationFileName(fromFileName);
   }
@@ -50209,7 +50248,7 @@ ${lanes.join("\n")}
             }
           }
           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) {
@@ -54010,7 +54049,11 @@ ${lanes.join("\n")}
         const baseTypeVariable = getBaseTypeVariableOfClass(symbol);
         return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
       } else {
-        return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(type) : type;
+        return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(
+          type,
+          /*isProperty*/
+          true
+        ) : type;
       }
     }
     function getTypeOfEnumMember(symbol) {
@@ -62490,7 +62533,7 @@ ${lanes.join("\n")}
                 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,
@@ -62711,6 +62754,7 @@ ${lanes.join("\n")}
         } else if (targetFlags & 8388608 /* IndexedAccess */) {
           if (sourceFlags & 8388608 /* IndexedAccess */) {
             if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, reportErrors2)) {
+              instantiateType(source2.objectType, reportUnreliableMapper);
               result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, reportErrors2);
             }
             if (result2) {
@@ -65856,7 +65900,7 @@ ${lanes.join("\n")}
       );
     }
     function isInAmbientOrTypeNode(node) {
-      return !!(node.flags & 16777216 /* Ambient */ || findAncestor(node, (n) => isInterfaceDeclaration(n) || isTypeLiteralNode(n)));
+      return !!(node.flags & 16777216 /* Ambient */ || findAncestor(node, (n) => isInterfaceDeclaration(n) || isTypeAliasDeclaration(n) || isTypeLiteralNode(n)));
     }
     function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
       switch (node.kind) {
@@ -69004,6 +69048,16 @@ ${lanes.join("\n")}
           const symbol = getSymbolOfDeclaration(element);
           return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
         }
+        if (hasDynamicName(element)) {
+          const name = getNameOfDeclaration(element);
+          if (name && isComputedPropertyName(name)) {
+            const exprType = checkExpression(name.expression);
+            const propType = isTypeUsableAsPropertyName(exprType) && getTypeOfPropertyOfContextualType(type, getPropertyNameFromType(exprType));
+            if (propType) {
+              return propType;
+            }
+          }
+        }
         if (element.name) {
           const nameType = getLiteralTypeFromPropertyName(element.name);
           return mapType(
@@ -73777,7 +73831,7 @@ ${lanes.join("\n")}
     }
     function getNonArrayRestType(signature) {
       const restType = getEffectiveRestType(signature);
-      return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072 /* Never */) === 0 ? restType : void 0;
+      return restType && !isArrayType(restType) && !isTypeAny(restType) ? restType : void 0;
     }
     function getTypeOfFirstParameterOfSignature(signature) {
       return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType);
@@ -78591,6 +78645,9 @@ ${lanes.join("\n")}
         return;
       }
       if (isBindingPattern(node.name)) {
+        if (isInAmbientOrTypeNode(node)) {
+          return;
+        }
         const needCheckInitializer = hasOnlyExpressionInitializer(node) && node.initializer && node.parent.parent.kind !== 246 /* ForInStatement */;
         const needCheckWidenedType = !some(node.name.elements, not(isOmittedExpression));
         if (needCheckInitializer || needCheckWidenedType) {
@@ -88009,6 +88066,7 @@ ${lanes.join("\n")}
     );
   }
   function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
+    const { factory: factory2 } = flattenContext.context;
     if (isComputedPropertyName(propertyName)) {
       const argumentExpression = ensureIdentifier(
         flattenContext,
@@ -88020,7 +88078,7 @@ ${lanes.join("\n")}
       );
       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));
@@ -88102,28 +88160,29 @@ ${lanes.join("\n")}
     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
         )
@@ -88131,17 +88190,17 @@ ${lanes.join("\n")}
     } 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(
@@ -88153,7 +88212,7 @@ ${lanes.join("\n")}
       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);
   }
   var ProcessLevel;
   var init_taggedTemplate = __esm({
@@ -91628,12 +91687,14 @@ ${lanes.join("\n")}
           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)
               );
@@ -91715,7 +91776,7 @@ ${lanes.join("\n")}
       Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
       statements.push(
         factory2.createExpressionStatement(
-          createPrivateInstanceMethodInitializer(receiver, weakSetName)
+          createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName)
         )
       );
     }
@@ -92168,25 +92229,25 @@ ${lanes.join("\n")}
       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]
@@ -92208,6 +92269,7 @@ ${lanes.join("\n")}
   // src/compiler/transformers/typeSerializer.ts
   function createRuntimeTypeSerializer(context) {
     const {
+      factory: factory2,
       hoistVariableDeclaration
     } = context;
     const resolver = context.getEmitResolver();
@@ -92247,9 +92309,9 @@ ${lanes.join("\n")}
         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) {
@@ -92270,7 +92332,7 @@ ${lanes.join("\n")}
           }
         }
       }
-      return factory.createArrayLiteralExpression(expressions);
+      return factory2.createArrayLiteralExpression(expressions);
     }
     function getParametersOfDecoratedDeclaration(node, container) {
       if (container && node.kind === 174 /* GetAccessor */) {
@@ -92285,39 +92347,39 @@ ${lanes.join("\n")}
       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 */:
@@ -92369,13 +92431,13 @@ ${lanes.join("\n")}
         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) {
@@ -92387,14 +92449,14 @@ ${lanes.join("\n")}
           }
         }
         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);
       }
@@ -92405,16 +92467,16 @@ ${lanes.join("\n")}
         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;
@@ -92425,13 +92487,13 @@ ${lanes.join("\n")}
         }
         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 (
@@ -92465,48 +92527,48 @@ ${lanes.join("\n")}
       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
       );
     }
@@ -92519,13 +92581,13 @@ ${lanes.join("\n")}
         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) {
@@ -92540,21 +92602,21 @@ ${lanes.join("\n")}
       }
     }
     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);
     }
   }
   var init_typeSerializer = __esm({
@@ -107500,7 +107562,7 @@ ${lanes.join("\n")}
       }
       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,
@@ -108614,8 +108676,8 @@ ${lanes.join("\n")}
     }
     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;
@@ -121571,7 +121633,7 @@ ${lanes.join("\n")}
       return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : void 0;
     }
     function createTypeRootsWatch(typeRootPath, typeRoot) {
-      return resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
+      return canWatchTypeRootPath(typeRootPath) ? resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
         const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
         if (cachedDirectoryStructureHost) {
           cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
@@ -121582,7 +121644,7 @@ ${lanes.join("\n")}
         if (dirPath) {
           scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
         }
-      }, 1 /* Recursive */);
+      }, 1 /* Recursive */) : noopFileWatcher;
     }
     function updateTypeRootsWatch() {
       const options = resolutionHost.getCompilationSettings();
@@ -121590,7 +121652,7 @@ ${lanes.join("\n")}
         closeTypeRootsWatch();
         return;
       }
-      const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
+      const typeRoots = getEffectiveTypeRoots(options, { getCurrentDirectory });
       if (typeRoots) {
         mutateMap(
           typeRootsWatches,
@@ -121604,7 +121666,9 @@ ${lanes.join("\n")}
         closeTypeRootsWatch();
       }
     }
-    function directoryExistsForTypeRootWatch(nodeTypesDirectory) {
+    function canWatchTypeRootPath(nodeTypesDirectory) {
+      if (resolutionHost.getCompilationSettings().typeRoots)
+        return true;
       const dir = getDirectoryPath(getDirectoryPath(nodeTypesDirectory));
       const dirPath = resolutionHost.toPath(dir);
       return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
@@ -131647,6 +131711,10 @@ ${lanes.join("\n")}
             diags.push(createDiagnosticForNode(init, Diagnostics.require_call_may_be_converted_to_an_import));
           }
         }
+        const jsdocTypedefNode = ts_codefix_exports.getJSDocTypedefNode(node);
+        if (jsdocTypedefNode) {
+          diags.push(createDiagnosticForNode(jsdocTypedefNode, Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type));
+        }
         if (ts_codefix_exports.parameterShouldGetTypeFromJSDoc(node)) {
           diags.push(createDiagnosticForNode(node.name || node, Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types));
         }
@@ -133462,18 +133530,6 @@ ${lanes.join("\n")}
       synchronizeHostData();
       return ts_FindAllReferences_exports.getImplementationsAtPosition(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
     }
-    function getOccurrencesAtPosition(fileName, position) {
-      return flatMap(
-        getDocumentHighlights(fileName, position, [fileName]),
-        (entry) => entry.highlightSpans.map((highlightSpan) => ({
-          fileName: entry.fileName,
-          textSpan: highlightSpan.textSpan,
-          isWriteAccess: highlightSpan.kind === "writtenReference" /* writtenReference */,
-          ...highlightSpan.isInString && { isInString: true },
-          ...highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan }
-        }))
-      );
-    }
     function getDocumentHighlights(fileName, position, filesToSearch) {
       const normalizedFileName = normalizePath(fileName);
       Debug.assert(filesToSearch.some((f) => normalizePath(f) === normalizedFileName));
@@ -133666,22 +133722,22 @@ ${lanes.join("\n")}
       }
       return [];
     }
-    function getCodeFixesAtPosition(fileName, start, end, errorCodes63, formatOptions, preferences = emptyOptions) {
+    function getCodeFixesAtPosition(fileName, start, end, errorCodes64, formatOptions, preferences = emptyOptions) {
       synchronizeHostData();
       const sourceFile = getValidSourceFile(fileName);
       const span = createTextSpanFromBounds(start, end);
       const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-      return flatMap(deduplicate(errorCodes63, equateValues, compareValues), (errorCode) => {
+      return flatMap(deduplicate(errorCodes64, equateValues, compareValues), (errorCode) => {
         cancellationToken.throwIfCancellationRequested();
         return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
       });
     }
-    function getCombinedCodeFix(scope, fixId51, formatOptions, preferences = emptyOptions) {
+    function getCombinedCodeFix(scope, fixId52, formatOptions, preferences = emptyOptions) {
       synchronizeHostData();
       Debug.assert(scope.type === "file");
       const sourceFile = getValidSourceFile(scope.fileName);
       const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-      return ts_codefix_exports.getAllFixes({ fixId: fixId51, sourceFile, program, host, cancellationToken, formatContext, preferences });
+      return ts_codefix_exports.getAllFixes({ fixId: fixId52, sourceFile, program, host, cancellationToken, formatContext, preferences });
     }
     function organizeImports2(args, formatOptions, preferences = emptyOptions) {
       var _a3;
@@ -134103,7 +134159,6 @@ ${lanes.join("\n")}
       getReferencesAtPosition,
       findReferences,
       getFileReferences,
-      getOccurrencesAtPosition,
       getDocumentHighlights,
       getNameOrDottedNameSpan,
       getBreakpointStatementAtPosition,
@@ -134929,7 +134984,6 @@ ${lanes.join("\n")}
         "getTypeDefinitionAtPosition",
         "getReferencesAtPosition",
         "findReferences",
-        "getOccurrencesAtPosition",
         "getDocumentHighlights",
         "getNavigateToItems",
         "getRenameInfo",
@@ -135513,12 +135567,6 @@ ${lanes.join("\n")}
             () => this.languageService.getFileReferences(fileName)
           );
         }
-        getOccurrencesAtPosition(fileName, position) {
-          return this.forwardJSONCall(
-            `getOccurrencesAtPosition('${fileName}', ${position})`,
-            () => this.languageService.getOccurrencesAtPosition(fileName, position)
-          );
-        }
         getDocumentHighlights(fileName, position, filesToSearch) {
           return this.forwardJSONCall(
             `getDocumentHighlights('${fileName}', ${position})`,
@@ -137152,23 +137200,23 @@ ${lanes.join("\n")}
       void 0
     );
   }
-  function createCodeFixAction(fixName8, changes, description2, fixId51, fixAllDescription, command) {
-    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId51, diagnosticToString(fixAllDescription), command);
+  function createCodeFixAction(fixName8, changes, description2, fixId52, fixAllDescription, command) {
+    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId52, diagnosticToString(fixAllDescription), command);
   }
-  function createCodeFixActionMaybeFixAll(fixName8, changes, description2, fixId51, fixAllDescription, command) {
-    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId51, fixAllDescription && diagnosticToString(fixAllDescription), command);
+  function createCodeFixActionMaybeFixAll(fixName8, changes, description2, fixId52, fixAllDescription, command) {
+    return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId52, fixAllDescription && diagnosticToString(fixAllDescription), command);
   }
-  function createCodeFixActionWorker(fixName8, description2, changes, fixId51, fixAllDescription, command) {
-    return { fixName: fixName8, description: description2, changes, fixId: fixId51, fixAllDescription, commands: command ? [command] : void 0 };
+  function createCodeFixActionWorker(fixName8, description2, changes, fixId52, fixAllDescription, command) {
+    return { fixName: fixName8, description: description2, changes, fixId: fixId52, fixAllDescription, commands: command ? [command] : void 0 };
   }
   function registerCodeFix(reg) {
     for (const error of reg.errorCodes) {
       errorCodeToFixes.add(String(error), reg);
     }
     if (reg.fixIds) {
-      for (const fixId51 of reg.fixIds) {
-        Debug.assert(!fixIdToRegistration.has(fixId51));
-        fixIdToRegistration.set(fixId51, reg);
+      for (const fixId52 of reg.fixIds) {
+        Debug.assert(!fixIdToRegistration.has(fixId52));
+        fixIdToRegistration.set(fixId52, reg);
       }
     }
   }
@@ -137176,17 +137224,17 @@ ${lanes.join("\n")}
     return arrayFrom(errorCodeToFixes.keys());
   }
   function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
-    const { errorCodes: errorCodes63 } = registration;
+    const { errorCodes: errorCodes64 } = registration;
     let maybeFixableDiagnostics = 0;
     for (const diag2 of diagnostics) {
-      if (contains(errorCodes63, diag2.code))
+      if (contains(errorCodes64, diag2.code))
         maybeFixableDiagnostics++;
       if (maybeFixableDiagnostics > 1)
         break;
     }
     const fixAllUnavailable = maybeFixableDiagnostics < 2;
-    return ({ fixId: fixId51, fixAllDescription, ...action }) => {
-      return fixAllUnavailable ? action : { ...action, fixId: fixId51, fixAllDescription };
+    return ({ fixId: fixId52, fixAllDescription, ...action }) => {
+      return fixAllUnavailable ? action : { ...action, fixId: fixId52, fixAllDescription };
     };
   }
   function getFixes(context) {
@@ -137203,14 +137251,14 @@ ${lanes.join("\n")}
   function createFileTextChanges(fileName, textChanges2) {
     return { fileName, textChanges: textChanges2 };
   }
-  function codeFixAll(context, errorCodes63, use) {
+  function codeFixAll(context, errorCodes64, use) {
     const commands = [];
-    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes63, (diag2) => use(t, diag2, commands)));
+    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes64, (diag2) => use(t, diag2, commands)));
     return createCombinedCodeActions(changes, commands.length === 0 ? void 0 : commands);
   }
-  function eachDiagnostic(context, errorCodes63, cb) {
+  function eachDiagnostic(context, errorCodes64, cb) {
     for (const diag2 of getDiagnostics(context)) {
-      if (contains(errorCodes63, diag2.code)) {
+      if (contains(errorCodes64, diag2.code)) {
         cb(diag2);
       }
     }
@@ -139792,32 +139840,96 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/convertToTypeOnlyImport.ts
-  function getImportDeclarationForDiagnosticSpan(span, sourceFile) {
-    return tryCast(getTokenAtPosition(sourceFile, span.start).parent, isImportDeclaration);
+  function getDeclaration2(sourceFile, pos) {
+    const { parent: parent2 } = getTokenAtPosition(sourceFile, pos);
+    return isImportSpecifier(parent2) || isImportDeclaration(parent2) && parent2.importClause ? parent2 : void 0;
   }
-  function fixSingleImportDeclaration(changes, importDeclaration, context) {
-    if (!(importDeclaration == null ? void 0 : importDeclaration.importClause)) {
-      return;
-    }
-    const { importClause } = importDeclaration;
-    changes.insertText(context.sourceFile, importDeclaration.getStart() + "import".length, " type");
-    if (importClause.name && importClause.namedBindings) {
-      changes.deleteNodeRangeExcludingEnd(context.sourceFile, importClause.name, importDeclaration.importClause.namedBindings);
-      changes.insertNodeBefore(context.sourceFile, importDeclaration, factory.updateImportDeclaration(
-        importDeclaration,
-        /*modifiers*/
-        void 0,
-        factory.createImportClause(
-          /*isTypeOnly*/
-          true,
-          importClause.name,
-          /*namedBindings*/
-          void 0
-        ),
-        importDeclaration.moduleSpecifier,
-        /*assertClause*/
-        void 0
+  function doChange4(changes, sourceFile, declaration) {
+    if (isImportSpecifier(declaration)) {
+      changes.replaceNode(sourceFile, declaration, factory.updateImportSpecifier(
+        declaration,
+        /*isTypeOnly*/
+        true,
+        declaration.propertyName,
+        declaration.name
       ));
+    } else {
+      const importClause = declaration.importClause;
+      if (importClause.name && importClause.namedBindings) {
+        changes.replaceNodeWithNodes(sourceFile, declaration, [
+          factory.createImportDeclaration(
+            getSynthesizedDeepClones(
+              declaration.modifiers,
+              /*includeTrivia*/
+              true
+            ),
+            factory.createImportClause(
+              /*isTypeOnly*/
+              true,
+              getSynthesizedDeepClone(
+                importClause.name,
+                /*includeTrivia*/
+                true
+              ),
+              /*namedBindings*/
+              void 0
+            ),
+            getSynthesizedDeepClone(
+              declaration.moduleSpecifier,
+              /*includeTrivia*/
+              true
+            ),
+            getSynthesizedDeepClone(
+              declaration.assertClause,
+              /*includeTrivia*/
+              true
+            )
+          ),
+          factory.createImportDeclaration(
+            getSynthesizedDeepClones(
+              declaration.modifiers,
+              /*includeTrivia*/
+              true
+            ),
+            factory.createImportClause(
+              /*isTypeOnly*/
+              true,
+              /*name*/
+              void 0,
+              getSynthesizedDeepClone(
+                importClause.namedBindings,
+                /*includeTrivia*/
+                true
+              )
+            ),
+            getSynthesizedDeepClone(
+              declaration.moduleSpecifier,
+              /*includeTrivia*/
+              true
+            ),
+            getSynthesizedDeepClone(
+              declaration.assertClause,
+              /*includeTrivia*/
+              true
+            )
+          )
+        ]);
+      } else {
+        const importDeclaration = factory.updateImportDeclaration(
+          declaration,
+          declaration.modifiers,
+          factory.updateImportClause(
+            importClause,
+            /*isTypeOnly*/
+            true,
+            importClause.name,
+            importClause.namedBindings
+          ),
+          declaration.moduleSpecifier,
+          declaration.assertClause
+        );
+        changes.replaceNode(sourceFile, declaration, importDeclaration);
+      }
     }
   }
   var errorCodes14, fixId13;
@@ -139826,30 +139938,181 @@ ${lanes.join("\n")}
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes14 = [Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code];
+      errorCodes14 = [
+        Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code,
+        Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled.code
+      ];
       fixId13 = "convertToTypeOnlyImport";
       registerCodeFix({
         errorCodes: errorCodes14,
         getCodeActions: function getCodeActionsToConvertToTypeOnlyImport(context) {
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
-            const importDeclaration = getImportDeclarationForDiagnosticSpan(context.span, context.sourceFile);
-            fixSingleImportDeclaration(t, importDeclaration, context);
-          });
-          if (changes.length) {
+          const declaration = getDeclaration2(context.sourceFile, context.span.start);
+          if (declaration) {
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange4(t, context.sourceFile, declaration));
             return [createCodeFixAction(fixId13, changes, Diagnostics.Convert_to_type_only_import, fixId13, Diagnostics.Convert_all_imports_not_used_as_a_value_to_type_only_imports)];
           }
+          return void 0;
         },
         fixIds: [fixId13],
         getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyImport(context) {
           return codeFixAll(context, errorCodes14, (changes, diag2) => {
-            const importDeclaration = getImportDeclarationForDiagnosticSpan(diag2, context.sourceFile);
-            fixSingleImportDeclaration(changes, importDeclaration, context);
+            const declaration = getDeclaration2(diag2.file, diag2.start);
+            if (declaration) {
+              doChange4(changes, diag2.file, declaration);
+            }
           });
         }
       });
     }
   });
 
+  // src/services/codefixes/convertTypedefToType.ts
+  function doChange5(changes, node, sourceFile) {
+    if (isJSDocTypedefTag(node)) {
+      fixSingleTypeDef(changes, node, sourceFile);
+    }
+  }
+  function fixSingleTypeDef(changes, typeDefNode, sourceFile) {
+    if (!typeDefNode)
+      return;
+    const declaration = createDeclaration(typeDefNode);
+    if (!declaration)
+      return;
+    const comment = typeDefNode.parent;
+    changes.replaceNode(
+      sourceFile,
+      comment,
+      declaration
+    );
+  }
+  function createDeclaration(tag) {
+    var _a2;
+    const { typeExpression } = tag;
+    if (!typeExpression)
+      return;
+    const typeName = (_a2 = tag.name) == null ? void 0 : _a2.getText();
+    if (!typeName)
+      return;
+    if (typeExpression.kind === 325 /* JSDocTypeLiteral */) {
+      return createInterfaceForTypeLiteral(typeName, typeExpression);
+    }
+    if (typeExpression.kind === 312 /* JSDocTypeExpression */) {
+      return createTypeAliasForTypeExpression(typeName, typeExpression);
+    }
+  }
+  function createInterfaceForTypeLiteral(typeName, typeLiteral) {
+    const propertySignatures = createSignatureFromTypeLiteral(typeLiteral);
+    if (!some(propertySignatures))
+      return;
+    const interfaceDeclaration = factory.createInterfaceDeclaration(
+      /*modifiers*/
+      void 0,
+      typeName,
+      /*typeParameters*/
+      void 0,
+      /*heritageClauses*/
+      void 0,
+      propertySignatures
+    );
+    return interfaceDeclaration;
+  }
+  function createTypeAliasForTypeExpression(typeName, typeExpression) {
+    const typeReference = getSynthesizedDeepClone(typeExpression.type);
+    if (!typeReference)
+      return;
+    const declaration = factory.createTypeAliasDeclaration(
+      /*modifiers*/
+      void 0,
+      factory.createIdentifier(typeName),
+      /*typeParameters*/
+      void 0,
+      typeReference
+    );
+    return declaration;
+  }
+  function createSignatureFromTypeLiteral(typeLiteral) {
+    const propertyTags = typeLiteral.jsDocPropertyTags;
+    if (!some(propertyTags))
+      return;
+    const getSignature = (tag) => {
+      var _a2;
+      const name = getPropertyName(tag);
+      const type = (_a2 = tag.typeExpression) == null ? void 0 : _a2.type;
+      const isOptional = tag.isBracketed;
+      let typeReference;
+      if (type && isJSDocTypeLiteral(type)) {
+        const signatures = createSignatureFromTypeLiteral(type);
+        typeReference = factory.createTypeLiteralNode(signatures);
+      } else if (type) {
+        typeReference = getSynthesizedDeepClone(type);
+      }
+      if (typeReference && name) {
+        const questionToken = isOptional ? factory.createToken(57 /* QuestionToken */) : void 0;
+        const prop = factory.createPropertySignature(
+          /*modifiers*/
+          void 0,
+          name,
+          questionToken,
+          typeReference
+        );
+        return prop;
+      }
+    };
+    const props = mapDefined(propertyTags, getSignature);
+    return props;
+  }
+  function getPropertyName(tag) {
+    return tag.name.kind === 79 /* Identifier */ ? tag.name.text : tag.name.right.text;
+  }
+  function getJSDocTypedefNode(node) {
+    if (hasJSDocNodes(node)) {
+      return forEach(node.jsDoc, (node2) => {
+        var _a2;
+        return (_a2 = node2.tags) == null ? void 0 : _a2.find(isJSDocTypedefTag);
+      });
+    }
+    return void 0;
+  }
+  var fixId14, errorCodes15;
+  var init_convertTypedefToType = __esm({
+    "src/services/codefixes/convertTypedefToType.ts"() {
+      "use strict";
+      init_ts4();
+      init_ts_codefix();
+      fixId14 = "convertTypedefToType";
+      errorCodes15 = [Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type.code];
+      registerCodeFix({
+        fixIds: [fixId14],
+        errorCodes: errorCodes15,
+        getCodeActions(context) {
+          const node = getTokenAtPosition(
+            context.sourceFile,
+            context.span.start
+          );
+          if (!node)
+            return;
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange5(t, node, context.sourceFile));
+          if (changes.length > 0) {
+            return [
+              createCodeFixAction(
+                fixId14,
+                changes,
+                Diagnostics.Convert_typedef_to_TypeScript_type,
+                fixId14,
+                Diagnostics.Convert_all_typedef_to_TypeScript_types
+              )
+            ];
+          }
+        },
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes15, (changes, diag2) => {
+          const node = getTokenAtPosition(diag2.file, diag2.start);
+          if (node)
+            doChange5(changes, node, diag2.file);
+        })
+      });
+    }
+  });
+
   // src/services/codefixes/convertLiteralTypeToMappedType.ts
   function getInfo2(sourceFile, pos) {
     const token = getTokenAtPosition(sourceFile, pos);
@@ -139865,7 +140128,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  function doChange4(changes, sourceFile, { container, typeNode, constraint, name }) {
+  function doChange6(changes, sourceFile, { container, typeNode, constraint, name }) {
     changes.replaceNode(sourceFile, container, factory.createMappedTypeNode(
       /*readonlyToken*/
       void 0,
@@ -139884,16 +140147,16 @@ ${lanes.join("\n")}
       void 0
     ));
   }
-  var fixId14, errorCodes15;
+  var fixId15, errorCodes16;
   var init_convertLiteralTypeToMappedType = __esm({
     "src/services/codefixes/convertLiteralTypeToMappedType.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId14 = "convertLiteralTypeToMappedType";
-      errorCodes15 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code];
+      fixId15 = "convertLiteralTypeToMappedType";
+      errorCodes16 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code];
       registerCodeFix({
-        errorCodes: errorCodes15,
+        errorCodes: errorCodes16,
         getCodeActions: function getCodeActionsToConvertLiteralTypeToMappedType(context) {
           const { sourceFile, span } = context;
           const info = getInfo2(sourceFile, span.start);
@@ -139901,14 +140164,14 @@ ${lanes.join("\n")}
             return void 0;
           }
           const { name, constraint } = info;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange4(t, sourceFile, info));
-          return [createCodeFixAction(fixId14, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId14, Diagnostics.Convert_all_type_literals_to_mapped_type)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange6(t, sourceFile, info));
+          return [createCodeFixAction(fixId15, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId15, Diagnostics.Convert_all_type_literals_to_mapped_type)];
         },
-        fixIds: [fixId14],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes15, (changes, diag2) => {
+        fixIds: [fixId15],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes16, (changes, diag2) => {
           const info = getInfo2(diag2.file, diag2.start);
           if (info) {
-            doChange4(changes, diag2.file, info);
+            doChange6(changes, diag2.file, info);
           }
         })
       });
@@ -139967,31 +140230,31 @@ ${lanes.join("\n")}
     const heritageClauseTypeSymbols = checker.getPropertiesOfType(heritageClauseType);
     return createSymbolTable(heritageClauseTypeSymbols.filter(symbolPointsToNonPrivateMember));
   }
-  var errorCodes16, fixId15;
+  var errorCodes17, fixId16;
   var init_fixClassIncorrectlyImplementsInterface = __esm({
     "src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes16 = [
+      errorCodes17 = [
         Diagnostics.Class_0_incorrectly_implements_interface_1.code,
         Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code
       ];
-      fixId15 = "fixClassIncorrectlyImplementsInterface";
+      fixId16 = "fixClassIncorrectlyImplementsInterface";
       registerCodeFix({
-        errorCodes: errorCodes16,
+        errorCodes: errorCodes17,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const classDeclaration = getClass(sourceFile, span.start);
           return mapDefined(getEffectiveImplementsTypeNodes(classDeclaration), (implementedTypeNode) => {
             const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, t, context.preferences));
-            return changes.length === 0 ? void 0 : createCodeFixAction(fixId15, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId15, Diagnostics.Implement_all_unimplemented_interfaces);
+            return changes.length === 0 ? void 0 : createCodeFixAction(fixId16, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId16, Diagnostics.Implement_all_unimplemented_interfaces);
           });
         },
-        fixIds: [fixId15],
+        fixIds: [fixId16],
         getAllCodeActions(context) {
           const seenClassDeclarations = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes16, (changes, diag2) => {
+          return codeFixAll(context, errorCodes17, (changes, diag2) => {
             const classDeclaration = getClass(diag2.file, diag2.start);
             if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
               for (const implementedTypeNode of getEffectiveImplementsTypeNodes(classDeclaration)) {
@@ -141165,7 +141428,7 @@ ${lanes.join("\n")}
     }
     return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
   }
-  var importFixName, importFixId, errorCodes17;
+  var importFixName, importFixId, errorCodes18;
   var init_importFixes = __esm({
     "src/services/codefixes/importFixes.ts"() {
       "use strict";
@@ -141173,7 +141436,7 @@ ${lanes.join("\n")}
       init_ts_codefix();
       importFixName = "import";
       importFixId = "fixMissingImport";
-      errorCodes17 = [
+      errorCodes18 = [
         Diagnostics.Cannot_find_name_0.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
@@ -141185,7 +141448,7 @@ ${lanes.join("\n")}
         Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes17,
+        errorCodes: errorCodes18,
         getCodeActions(context) {
           const { errorCode, preferences, sourceFile, span, program } = context;
           const info = getFixInfos(
@@ -141220,7 +141483,7 @@ ${lanes.join("\n")}
             host,
             cancellationToken
           );
-          eachDiagnostic(context, errorCodes17, (diag2) => importAdder.addImportFromDiagnostic(diag2, context));
+          eachDiagnostic(context, errorCodes18, (diag2) => importAdder.addImportFromDiagnostic(diag2, context));
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, importAdder.writeFixes));
         }
       });
@@ -141295,14 +141558,14 @@ ${lanes.join("\n")}
     const contextualType = isExpression(node) ? checker.getContextualType(node) : void 0;
     return contextualType || checker.getTypeAtLocation(node);
   }
-  var fixId16, errorCodes18;
+  var fixId17, errorCodes19;
   var init_fixAddMissingConstraint = __esm({
     "src/services/codefixes/fixAddMissingConstraint.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId16 = "addMissingConstraint";
-      errorCodes18 = [
+      fixId17 = "addMissingConstraint";
+      errorCodes19 = [
         // We want errors this could be attached to:
         // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
         Diagnostics.Type_0_is_not_comparable_to_type_1.code,
@@ -141315,21 +141578,21 @@ ${lanes.join("\n")}
         Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes18,
+        errorCodes: errorCodes19,
         getCodeActions(context) {
           const { sourceFile, span, program, preferences, host } = context;
           const info = getInfo3(program, sourceFile, span);
           if (info === void 0)
             return;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingConstraint(t, program, preferences, host, sourceFile, info));
-          return [createCodeFixAction(fixId16, changes, Diagnostics.Add_extends_constraint, fixId16, Diagnostics.Add_extends_constraint_to_all_type_parameters)];
+          return [createCodeFixAction(fixId17, changes, Diagnostics.Add_extends_constraint, fixId17, Diagnostics.Add_extends_constraint_to_all_type_parameters)];
         },
-        fixIds: [fixId16],
+        fixIds: [fixId17],
         getAllCodeActions: (context) => {
           const { program, preferences, host } = context;
           const seen = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes18, (diag2) => {
+            eachDiagnostic(context, errorCodes19, (diag2) => {
               const info = getInfo3(program, diag2.file, createTextSpan(diag2.start, diag2.length));
               if (info) {
                 if (addToSeen(seen, getNodeId(info.declaration))) {
@@ -141411,7 +141674,7 @@ ${lanes.join("\n")}
     Debug.assert(classElement && isClassElementLikeHasJSDoc(classElement));
     return classElement;
   }
-  var fixName, fixAddOverrideId, fixRemoveOverrideId, errorCodes19, errorCodeFixIdMap;
+  var fixName, fixAddOverrideId, fixRemoveOverrideId, errorCodes20, errorCodeFixIdMap;
   var init_fixOverrideModifier = __esm({
     "src/services/codefixes/fixOverrideModifier.ts"() {
       "use strict";
@@ -141420,7 +141683,7 @@ ${lanes.join("\n")}
       fixName = "fixOverrideModifier";
       fixAddOverrideId = "fixAddOverrideModifier";
       fixRemoveOverrideId = "fixRemoveOverrideModifier";
-      errorCodes19 = [
+      errorCodes20 = [
         Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code,
         Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code,
         Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code,
@@ -141484,20 +141747,20 @@ ${lanes.join("\n")}
         }
       };
       registerCodeFix({
-        errorCodes: errorCodes19,
+        errorCodes: errorCodes20,
         getCodeActions: function getCodeActionsToFixOverrideModifierIssues(context) {
           const { errorCode, span } = context;
           const info = errorCodeFixIdMap[errorCode];
           if (!info)
             return emptyArray;
-          const { descriptions, fixId: fixId51, fixAllDescriptions } = info;
+          const { descriptions, fixId: fixId52, fixAllDescriptions } = info;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start));
           return [
-            createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId51, fixAllDescriptions)
+            createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId52, fixAllDescriptions)
           ];
         },
         fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes19, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes20, (changes, diag2) => {
           const { code, start } = diag2;
           const info = errorCodeFixIdMap[code];
           if (!info || info.fixId !== context.fixId) {
@@ -141510,7 +141773,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts
-  function doChange5(changes, sourceFile, node, preferences) {
+  function doChange7(changes, sourceFile, node, preferences) {
     const quotePreference = getQuotePreference(sourceFile, preferences);
     const argumentsExpression = factory.createStringLiteral(node.name.text, quotePreference === 0 /* Single */);
     changes.replaceNode(
@@ -141522,32 +141785,32 @@ ${lanes.join("\n")}
   function getPropertyAccessExpression(sourceFile, pos) {
     return cast(getTokenAtPosition(sourceFile, pos).parent, isPropertyAccessExpression);
   }
-  var fixId17, errorCodes20;
+  var fixId18, errorCodes21;
   var init_fixNoPropertyAccessFromIndexSignature = __esm({
     "src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId17 = "fixNoPropertyAccessFromIndexSignature";
-      errorCodes20 = [
+      fixId18 = "fixNoPropertyAccessFromIndexSignature";
+      errorCodes21 = [
         Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes20,
-        fixIds: [fixId17],
+        errorCodes: errorCodes21,
+        fixIds: [fixId18],
         getCodeActions(context) {
           const { sourceFile, span, preferences } = context;
           const property = getPropertyAccessExpression(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange5(t, context.sourceFile, property, preferences));
-          return [createCodeFixAction(fixId17, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId17, Diagnostics.Use_element_access_for_all_undeclared_properties)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange7(t, context.sourceFile, property, preferences));
+          return [createCodeFixAction(fixId18, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId18, Diagnostics.Use_element_access_for_all_undeclared_properties)];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes20, (changes, diag2) => doChange5(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => doChange7(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
       });
     }
   });
 
   // src/services/codefixes/fixImplicitThis.ts
-  function doChange6(changes, sourceFile, pos, checker) {
+  function doChange8(changes, sourceFile, pos, checker) {
     const token = getTokenAtPosition(sourceFile, pos);
     if (!isThis(token))
       return void 0;
@@ -141588,27 +141851,27 @@ ${lanes.join("\n")}
       }
     }
   }
-  var fixId18, errorCodes21;
+  var fixId19, errorCodes22;
   var init_fixImplicitThis = __esm({
     "src/services/codefixes/fixImplicitThis.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId18 = "fixImplicitThis";
-      errorCodes21 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
+      fixId19 = "fixImplicitThis";
+      errorCodes22 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
       registerCodeFix({
-        errorCodes: errorCodes21,
+        errorCodes: errorCodes22,
         getCodeActions: function getCodeActionsToFixImplicitThis(context) {
           const { sourceFile, program, span } = context;
           let diagnostic;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
-            diagnostic = doChange6(t, sourceFile, span.start, program.getTypeChecker());
+            diagnostic = doChange8(t, sourceFile, span.start, program.getTypeChecker());
           });
-          return diagnostic ? [createCodeFixAction(fixId18, changes, diagnostic, fixId18, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray;
+          return diagnostic ? [createCodeFixAction(fixId19, changes, diagnostic, fixId19, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray;
         },
-        fixIds: [fixId18],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => {
-          doChange6(changes, diag2.file, diag2.start, context.program.getTypeChecker());
+        fixIds: [fixId19],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes22, (changes, diag2) => {
+          doChange8(changes, diag2.file, diag2.start, context.program.getTypeChecker());
         })
       });
     }
@@ -141651,7 +141914,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  function doChange7(changes, program, { exportName, node, moduleSourceFile }) {
+  function doChange9(changes, program, { exportName, node, moduleSourceFile }) {
     const exportDeclaration = tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly);
     if (exportDeclaration) {
       updateExport(changes, program, moduleSourceFile, exportDeclaration, [exportName]);
@@ -141733,32 +141996,32 @@ ${lanes.join("\n")}
     const variableStatement = isVariableDeclaration(declaration) ? tryCast(declaration.parent.parent, isVariableStatement) : void 0;
     return variableStatement && length(variableStatement.declarationList.declarations) === 1 ? variableStatement : declaration;
   }
-  var fixId19, errorCodes22;
+  var fixId20, errorCodes23;
   var init_fixImportNonExportedMember = __esm({
     "src/services/codefixes/fixImportNonExportedMember.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId19 = "fixImportNonExportedMember";
-      errorCodes22 = [
+      fixId20 = "fixImportNonExportedMember";
+      errorCodes23 = [
         Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes22,
-        fixIds: [fixId19],
+        errorCodes: errorCodes23,
+        fixIds: [fixId20],
         getCodeActions(context) {
           const { sourceFile, span, program } = context;
           const info = getInfo4(sourceFile, span.start, program);
           if (info === void 0)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange7(t, program, info));
-          return [createCodeFixAction(fixId19, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId19, Diagnostics.Export_all_referenced_locals)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange9(t, program, info));
+          return [createCodeFixAction(fixId20, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId20, Diagnostics.Export_all_referenced_locals)];
         },
         getAllCodeActions(context) {
           const { program } = context;
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
             const exports = /* @__PURE__ */ new Map();
-            eachDiagnostic(context, errorCodes22, (diag2) => {
+            eachDiagnostic(context, errorCodes23, (diag2) => {
               const info = getInfo4(diag2.file, diag2.start, program);
               if (info === void 0)
                 return void 0;
@@ -141803,7 +142066,7 @@ ${lanes.join("\n")}
     const token = getTokenAtPosition(sourceFile, pos);
     return findAncestor(token, (t) => t.kind === 199 /* NamedTupleMember */);
   }
-  function doChange8(changes, sourceFile, namedTupleMember) {
+  function doChange10(changes, sourceFile, namedTupleMember) {
     if (!namedTupleMember) {
       return;
     }
@@ -141830,26 +142093,26 @@ ${lanes.join("\n")}
     }
     changes.replaceNode(sourceFile, namedTupleMember, updated);
   }
-  var fixId20, errorCodes23;
+  var fixId21, errorCodes24;
   var init_fixIncorrectNamedTupleSyntax = __esm({
     "src/services/codefixes/fixIncorrectNamedTupleSyntax.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId20 = "fixIncorrectNamedTupleSyntax";
-      errorCodes23 = [
+      fixId21 = "fixIncorrectNamedTupleSyntax";
+      errorCodes24 = [
         Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code,
         Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes23,
+        errorCodes: errorCodes24,
         getCodeActions: function getCodeActionsToFixIncorrectNamedTupleSyntax(context) {
           const { sourceFile, span } = context;
           const namedTupleMember = getNamedTupleMember(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange8(t, sourceFile, namedTupleMember));
-          return [createCodeFixAction(fixId20, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId20, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange10(t, sourceFile, namedTupleMember));
+          return [createCodeFixAction(fixId21, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId21, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)];
         },
-        fixIds: [fixId20]
+        fixIds: [fixId21]
       });
     }
   });
@@ -141904,7 +142167,7 @@ ${lanes.join("\n")}
     }
     return suggestedSymbol === void 0 ? void 0 : { node, suggestedSymbol };
   }
-  function doChange9(changes, sourceFile, node, suggestedSymbol, target) {
+  function doChange11(changes, sourceFile, node, suggestedSymbol, target) {
     const suggestion = symbolName(suggestedSymbol);
     if (!isIdentifierText(suggestion, target) && isPropertyAccessExpression(node.parent)) {
       const valDecl = suggestedSymbol.valueDeclaration;
@@ -141938,14 +142201,14 @@ ${lanes.join("\n")}
       return void 0;
     return context.program.getSourceFile(resolvedModule.resolvedFileName);
   }
-  var fixId21, errorCodes24;
+  var fixId22, errorCodes25;
   var init_fixSpelling = __esm({
     "src/services/codefixes/fixSpelling.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId21 = "fixSpelling";
-      errorCodes24 = [
+      fixId22 = "fixSpelling";
+      errorCodes25 = [
         Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
         Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
@@ -141962,7 +142225,7 @@ ${lanes.join("\n")}
         Diagnostics.Type_0_is_not_assignable_to_type_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes24,
+        errorCodes: errorCodes25,
         getCodeActions(context) {
           const { sourceFile, errorCode } = context;
           const info = getInfo5(sourceFile, context.span.start, context, errorCode);
@@ -141970,15 +142233,15 @@ ${lanes.join("\n")}
             return void 0;
           const { node, suggestedSymbol } = info;
           const target = getEmitScriptTarget(context.host.getCompilationSettings());
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange9(t, sourceFile, node, suggestedSymbol, target));
-          return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId21, Diagnostics.Fix_all_detected_spelling_errors)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, sourceFile, node, suggestedSymbol, target));
+          return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId22, Diagnostics.Fix_all_detected_spelling_errors)];
         },
-        fixIds: [fixId21],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes24, (changes, diag2) => {
+        fixIds: [fixId22],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes25, (changes, diag2) => {
           const info = getInfo5(diag2.file, diag2.start, context, diag2.code);
           const target = getEmitScriptTarget(context.host.getCompilationSettings());
           if (info)
-            doChange9(changes, context.sourceFile, info.node, info.suggestedSymbol, target);
+            doChange11(changes, context.sourceFile, info.node, info.suggestedSymbol, target);
         })
       });
     }
@@ -142162,7 +142425,7 @@ ${lanes.join("\n")}
   }
   function getActionForfixAddReturnStatement(context, expression, statement) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addReturnStatement(t, context.sourceFile, expression, statement));
-    return createCodeFixAction(fixId22, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
+    return createCodeFixAction(fixId23, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
   }
   function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration, expression, commentSource) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => removeBlockBodyBrace(
@@ -142174,29 +142437,29 @@ ${lanes.join("\n")}
       /* withParen */
       false
     ));
-    return createCodeFixAction(fixId22, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues);
+    return createCodeFixAction(fixId23, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues);
   }
   function getActionForfixWrapTheBlockWithParen(context, declaration, expression) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => wrapBlockWithParen(t, context.sourceFile, declaration, expression));
-    return createCodeFixAction(fixId22, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses);
+    return createCodeFixAction(fixId23, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses);
   }
-  var fixId22, fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen, errorCodes25;
+  var fixId23, fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen, errorCodes26;
   var init_returnValueCorrect = __esm({
     "src/services/codefixes/returnValueCorrect.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId22 = "returnValueCorrect";
+      fixId23 = "returnValueCorrect";
       fixIdAddReturnStatement = "fixAddReturnStatement";
       fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody";
       fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen";
-      errorCodes25 = [
+      errorCodes26 = [
         Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code,
         Diagnostics.Type_0_is_not_assignable_to_type_1.code,
         Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes25,
+        errorCodes: errorCodes26,
         fixIds: [fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen],
         getCodeActions: function getCodeActionsToCorrectReturnValue(context) {
           const { program, sourceFile, span: { start }, errorCode } = context;
@@ -142212,7 +142475,7 @@ ${lanes.join("\n")}
             return [getActionForfixWrapTheBlockWithParen(context, info.declaration, info.expression)];
           }
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes25, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes26, (changes, diag2) => {
           const info = getInfo6(context.program.getTypeChecker(), diag2.file, diag2.start, diag2.code);
           if (!info)
             return void 0;
@@ -142778,7 +143041,7 @@ ${lanes.join("\n")}
     }
     return getSourceFileOfNode(node);
   }
-  var fixMissingMember, fixMissingProperties, fixMissingAttributes, fixMissingFunctionDeclaration, errorCodes26;
+  var fixMissingMember, fixMissingProperties, fixMissingAttributes, fixMissingFunctionDeclaration, errorCodes27;
   var init_fixAddMissingMember = __esm({
     "src/services/codefixes/fixAddMissingMember.ts"() {
       "use strict";
@@ -142788,7 +143051,7 @@ ${lanes.join("\n")}
       fixMissingProperties = "fixMissingProperties";
       fixMissingAttributes = "fixMissingAttributes";
       fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration";
-      errorCodes26 = [
+      errorCodes27 = [
         Diagnostics.Property_0_does_not_exist_on_type_1.code,
         Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
         Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2.code,
@@ -142798,7 +143061,7 @@ ${lanes.join("\n")}
         Diagnostics.Cannot_find_name_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes26,
+        errorCodes: errorCodes27,
         getCodeActions(context) {
           const typeChecker = context.program.getTypeChecker();
           const info = getInfo7(context.sourceFile, context.span.start, context.errorCode, typeChecker, context.program);
@@ -142825,21 +143088,21 @@ ${lanes.join("\n")}
         },
         fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes],
         getAllCodeActions: (context) => {
-          const { program, fixId: fixId51 } = context;
+          const { program, fixId: fixId52 } = context;
           const checker = program.getTypeChecker();
           const seen = /* @__PURE__ */ new Map();
           const typeDeclToMembers = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes26, (diag2) => {
+            eachDiagnostic(context, errorCodes27, (diag2) => {
               const info = getInfo7(diag2.file, diag2.start, diag2.code, checker, context.program);
               if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + info.token.text)) {
                 return;
               }
-              if (fixId51 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
+              if (fixId52 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
                 addFunctionDeclaration(changes, context, info);
-              } else if (fixId51 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
+              } else if (fixId52 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
                 addObjectLiteralProperties(changes, context, info);
-              } else if (fixId51 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
+              } else if (fixId52 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
                 addJsxAttributes(changes, context, info);
               } else {
                 if (info.kind === 1 /* Enum */) {
@@ -142895,23 +143158,23 @@ ${lanes.join("\n")}
     }
     return token;
   }
-  var fixId23, errorCodes27;
+  var fixId24, errorCodes28;
   var init_fixAddMissingNewOperator = __esm({
     "src/services/codefixes/fixAddMissingNewOperator.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId23 = "addMissingNewOperator";
-      errorCodes27 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
+      fixId24 = "addMissingNewOperator";
+      errorCodes28 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
       registerCodeFix({
-        errorCodes: errorCodes27,
+        errorCodes: errorCodes28,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingNewOperator(t, sourceFile, span));
-          return [createCodeFixAction(fixId23, changes, Diagnostics.Add_missing_new_operator_to_call, fixId23, Diagnostics.Add_missing_new_operator_to_all_calls)];
+          return [createCodeFixAction(fixId24, changes, Diagnostics.Add_missing_new_operator_to_call, fixId24, Diagnostics.Add_missing_new_operator_to_all_calls)];
         },
-        fixIds: [fixId23],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes27, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2))
+        fixIds: [fixId24],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes28, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2))
       });
     }
   });
@@ -142932,7 +143195,7 @@ ${lanes.join("\n")}
     var _a2;
     return diagCode === errorCodeCannotFindModule ? ts_JsTyping_exports.nodeCoreModules.has(packageName) ? "@types/node" : void 0 : ((_a2 = host.isKnownTypesPackageName) == null ? void 0 : _a2.call(host, packageName)) ? getTypesPackageName(packageName) : void 0;
   }
-  var fixName2, fixIdInstallTypesPackage, errorCodeCannotFindModule, errorCodes28;
+  var fixName2, fixIdInstallTypesPackage, errorCodeCannotFindModule, errorCodes29;
   var init_fixCannotFindModule = __esm({
     "src/services/codefixes/fixCannotFindModule.ts"() {
       "use strict";
@@ -142941,12 +143204,12 @@ ${lanes.join("\n")}
       fixName2 = "fixCannotFindModule";
       fixIdInstallTypesPackage = "installTypesPackage";
       errorCodeCannotFindModule = Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations.code;
-      errorCodes28 = [
+      errorCodes29 = [
         errorCodeCannotFindModule,
         Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes28,
+        errorCodes: errorCodes29,
         getCodeActions: function getCodeActionsToFixNotFoundModule(context) {
           const { host, sourceFile, span: { start } } = context;
           const packageName = tryGetImportedPackageName(sourceFile, start);
@@ -142965,7 +143228,7 @@ ${lanes.join("\n")}
         },
         fixIds: [fixIdInstallTypesPackage],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes28, (_changes, diag2, commands) => {
+          return codeFixAll(context, errorCodes29, (_changes, diag2, commands) => {
             const packageName = tryGetImportedPackageName(diag2.file, diag2.start);
             if (packageName === void 0)
               return void 0;
@@ -143004,28 +143267,28 @@ ${lanes.join("\n")}
     const flags = getSyntacticModifierFlags(first(symbol.getDeclarations()));
     return !(flags & 8 /* Private */) && !!(flags & 256 /* Abstract */);
   }
-  var errorCodes29, fixId24;
+  var errorCodes30, fixId25;
   var init_fixClassDoesntImplementInheritedAbstractMember = __esm({
     "src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes29 = [
+      errorCodes30 = [
         Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code,
         Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code
       ];
-      fixId24 = "fixClassDoesntImplementInheritedAbstractMember";
+      fixId25 = "fixClassDoesntImplementInheritedAbstractMember";
       registerCodeFix({
-        errorCodes: errorCodes29,
+        errorCodes: errorCodes30,
         getCodeActions: function getCodeActionsToFixClassNotImplementingInheritedMembers(context) {
           const { sourceFile, span } = context;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMembers(getClass2(sourceFile, span.start), sourceFile, context, t, context.preferences));
-          return changes.length === 0 ? void 0 : [createCodeFixAction(fixId24, changes, Diagnostics.Implement_inherited_abstract_class, fixId24, Diagnostics.Implement_all_inherited_abstract_classes)];
+          return changes.length === 0 ? void 0 : [createCodeFixAction(fixId25, changes, Diagnostics.Implement_inherited_abstract_class, fixId25, Diagnostics.Implement_all_inherited_abstract_classes)];
         },
-        fixIds: [fixId24],
+        fixIds: [fixId25],
         getAllCodeActions: function getAllCodeActionsToFixClassDoesntImplementInheritedAbstractMember(context) {
           const seenClassDeclarations = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes29, (changes, diag2) => {
+          return codeFixAll(context, errorCodes30, (changes, diag2) => {
             const classDeclaration = getClass2(diag2.file, diag2.start);
             if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
               addMissingMembers(classDeclaration, context.sourceFile, context, changes, context.preferences);
@@ -143037,7 +143300,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts
-  function doChange10(changes, sourceFile, constructor, superCall) {
+  function doChange12(changes, sourceFile, constructor, superCall) {
     changes.insertNodeAtConstructorStart(sourceFile, constructor, superCall);
     changes.delete(sourceFile, superCall);
   }
@@ -143052,36 +143315,36 @@ ${lanes.join("\n")}
   function findSuperCall(n) {
     return isExpressionStatement(n) && isSuperCall(n.expression) ? n : isFunctionLike(n) ? void 0 : forEachChild(n, findSuperCall);
   }
-  var fixId25, errorCodes30;
+  var fixId26, errorCodes31;
   var init_fixClassSuperMustPrecedeThisAccess = __esm({
     "src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId25 = "classSuperMustPrecedeThisAccess";
-      errorCodes30 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code];
+      fixId26 = "classSuperMustPrecedeThisAccess";
+      errorCodes31 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code];
       registerCodeFix({
-        errorCodes: errorCodes30,
+        errorCodes: errorCodes31,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const nodes = getNodes(sourceFile, span.start);
           if (!nodes)
             return void 0;
           const { constructor, superCall } = nodes;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange10(t, sourceFile, constructor, superCall));
-          return [createCodeFixAction(fixId25, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId25, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange12(t, sourceFile, constructor, superCall));
+          return [createCodeFixAction(fixId26, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId26, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)];
         },
-        fixIds: [fixId25],
+        fixIds: [fixId26],
         getAllCodeActions(context) {
           const { sourceFile } = context;
           const seenClasses = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes30, (changes, diag2) => {
+          return codeFixAll(context, errorCodes31, (changes, diag2) => {
             const nodes = getNodes(diag2.file, diag2.start);
             if (!nodes)
               return;
             const { constructor, superCall } = nodes;
             if (addToSeen(seenClasses, getNodeId(constructor.parent))) {
-              doChange10(changes, sourceFile, constructor, superCall);
+              doChange12(changes, sourceFile, constructor, superCall);
             }
           });
         }
@@ -143095,7 +143358,7 @@ ${lanes.join("\n")}
     Debug.assert(isConstructorDeclaration(token.parent), "token should be at the constructor declaration");
     return token.parent;
   }
-  function doChange11(changes, sourceFile, ctr) {
+  function doChange13(changes, sourceFile, ctr) {
     const superCall = factory.createExpressionStatement(factory.createCallExpression(
       factory.createSuper(),
       /*typeArguments*/
@@ -143105,42 +143368,42 @@ ${lanes.join("\n")}
     ));
     changes.insertNodeAtConstructorStart(sourceFile, ctr, superCall);
   }
-  var fixId26, errorCodes31;
+  var fixId27, errorCodes32;
   var init_fixConstructorForDerivedNeedSuperCall = __esm({
     "src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId26 = "constructorForDerivedNeedSuperCall";
-      errorCodes31 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code];
+      fixId27 = "constructorForDerivedNeedSuperCall";
+      errorCodes32 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code];
       registerCodeFix({
-        errorCodes: errorCodes31,
+        errorCodes: errorCodes32,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const ctr = getNode(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, sourceFile, ctr));
-          return [createCodeFixAction(fixId26, changes, Diagnostics.Add_missing_super_call, fixId26, Diagnostics.Add_all_missing_super_calls)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange13(t, sourceFile, ctr));
+          return [createCodeFixAction(fixId27, changes, Diagnostics.Add_missing_super_call, fixId27, Diagnostics.Add_all_missing_super_calls)];
         },
-        fixIds: [fixId26],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes31, (changes, diag2) => doChange11(changes, context.sourceFile, getNode(diag2.file, diag2.start)))
+        fixIds: [fixId27],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes32, (changes, diag2) => doChange13(changes, context.sourceFile, getNode(diag2.file, diag2.start)))
       });
     }
   });
 
   // src/services/codefixes/fixEnableJsxFlag.ts
-  function doChange12(changeTracker, configFile) {
+  function doChange14(changeTracker, configFile) {
     setJsonCompilerOptionValue(changeTracker, configFile, "jsx", factory.createStringLiteral("react"));
   }
-  var fixID, errorCodes32;
+  var fixID, errorCodes33;
   var init_fixEnableJsxFlag = __esm({
     "src/services/codefixes/fixEnableJsxFlag.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixID = "fixEnableJsxFlag";
-      errorCodes32 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code];
+      errorCodes33 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code];
       registerCodeFix({
-        errorCodes: errorCodes32,
+        errorCodes: errorCodes33,
         getCodeActions: function getCodeActionsToFixEnableJsxFlag(context) {
           const { configFile } = context.program.getCompilerOptions();
           if (configFile === void 0) {
@@ -143148,19 +143411,19 @@ ${lanes.join("\n")}
           }
           const changes = ts_textChanges_exports.ChangeTracker.with(
             context,
-            (changeTracker) => doChange12(changeTracker, configFile)
+            (changeTracker) => doChange14(changeTracker, configFile)
           );
           return [
             createCodeFixActionWithoutFixAll(fixID, changes, Diagnostics.Enable_the_jsx_flag_in_your_configuration_file)
           ];
         },
         fixIds: [fixID],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes32, (changes) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes33, (changes) => {
           const { configFile } = context.program.getCompilerOptions();
           if (configFile === void 0) {
             return void 0;
           }
-          doChange12(changes, configFile);
+          doChange14(changes, configFile);
         })
       });
     }
@@ -143182,7 +143445,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  function doChange13(changes, sourceFile, arg, expression) {
+  function doChange15(changes, sourceFile, arg, expression) {
     const callExpression = factory.createCallExpression(
       factory.createPropertyAccessExpression(factory.createIdentifier("Number"), factory.createIdentifier("isNaN")),
       /*typeArguments*/
@@ -143200,33 +143463,33 @@ ${lanes.join("\n")}
     const [_, suggestion] = flattenDiagnosticMessageText(messageText, "\n", 0).match(/\'(.*)\'/) || [];
     return suggestion;
   }
-  var fixId27, errorCodes33;
+  var fixId28, errorCodes34;
   var init_fixNaNEquality = __esm({
     "src/services/codefixes/fixNaNEquality.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId27 = "fixNaNEquality";
-      errorCodes33 = [
+      fixId28 = "fixNaNEquality";
+      errorCodes34 = [
         Diagnostics.This_condition_will_always_return_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes33,
+        errorCodes: errorCodes34,
         getCodeActions(context) {
           const { sourceFile, span, program } = context;
           const info = getInfo8(program, sourceFile, span);
           if (info === void 0)
             return;
           const { suggestion, expression, arg } = info;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange13(t, sourceFile, arg, expression));
-          return [createCodeFixAction(fixId27, changes, [Diagnostics.Use_0, suggestion], fixId27, Diagnostics.Use_Number_isNaN_in_all_conditions)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange15(t, sourceFile, arg, expression));
+          return [createCodeFixAction(fixId28, changes, [Diagnostics.Use_0, suggestion], fixId28, Diagnostics.Use_Number_isNaN_in_all_conditions)];
         },
-        fixIds: [fixId27],
+        fixIds: [fixId28],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes33, (changes, diag2) => {
+          return codeFixAll(context, errorCodes34, (changes, diag2) => {
             const info = getInfo8(context.program, diag2.file, createTextSpan(diag2.start, diag2.length));
             if (info) {
-              doChange13(changes, diag2.file, info.arg, info.expression);
+              doChange15(changes, diag2.file, info.arg, info.expression);
             }
           });
         }
@@ -143282,32 +143545,32 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixPropertyAssignment.ts
-  function doChange14(changes, sourceFile, node) {
+  function doChange16(changes, sourceFile, node) {
     changes.replaceNode(sourceFile, node, factory.createPropertyAssignment(node.name, node.objectAssignmentInitializer));
   }
   function getProperty2(sourceFile, pos) {
     return cast(getTokenAtPosition(sourceFile, pos).parent, isShorthandPropertyAssignment);
   }
-  var fixId28, errorCodes34;
+  var fixId29, errorCodes35;
   var init_fixPropertyAssignment = __esm({
     "src/services/codefixes/fixPropertyAssignment.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId28 = "fixPropertyAssignment";
-      errorCodes34 = [
+      fixId29 = "fixPropertyAssignment";
+      errorCodes35 = [
         Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes34,
-        fixIds: [fixId28],
+        errorCodes: errorCodes35,
+        fixIds: [fixId29],
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const property = getProperty2(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, context.sourceFile, property));
-          return [createCodeFixAction(fixId28, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId28, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(t, context.sourceFile, property));
+          return [createCodeFixAction(fixId29, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId29, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes34, (changes, diag2) => doChange14(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => doChange16(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
       });
     }
   });
@@ -143333,16 +143596,16 @@ ${lanes.join("\n")}
       changes.deleteRange(sourceFile, { pos: implementsToken.getStart(), end });
     }
   }
-  var fixId29, errorCodes35;
+  var fixId30, errorCodes36;
   var init_fixExtendsInterfaceBecomesImplements = __esm({
     "src/services/codefixes/fixExtendsInterfaceBecomesImplements.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId29 = "extendsInterfaceBecomesImplements";
-      errorCodes35 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code];
+      fixId30 = "extendsInterfaceBecomesImplements";
+      errorCodes36 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code];
       registerCodeFix({
-        errorCodes: errorCodes35,
+        errorCodes: errorCodes36,
         getCodeActions(context) {
           const { sourceFile } = context;
           const nodes = getNodes2(sourceFile, context.span.start);
@@ -143350,10 +143613,10 @@ ${lanes.join("\n")}
             return void 0;
           const { extendsToken, heritageClauses } = nodes;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChanges2(t, sourceFile, extendsToken, heritageClauses));
-          return [createCodeFixAction(fixId29, changes, Diagnostics.Change_extends_to_implements, fixId29, Diagnostics.Change_all_extended_interfaces_to_implements)];
+          return [createCodeFixAction(fixId30, changes, Diagnostics.Change_extends_to_implements, fixId30, Diagnostics.Change_all_extended_interfaces_to_implements)];
         },
-        fixIds: [fixId29],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => {
+        fixIds: [fixId30],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes36, (changes, diag2) => {
           const nodes = getNodes2(diag2.file, diag2.start);
           if (nodes)
             doChanges2(changes, diag2.file, nodes.extendsToken, nodes.heritageClauses);
@@ -143369,39 +143632,39 @@ ${lanes.join("\n")}
       return { node, className: diagCode === didYouMeanStaticMemberCode ? getContainingClass(node).name.text : void 0 };
     }
   }
-  function doChange15(changes, sourceFile, { node, className }) {
+  function doChange17(changes, sourceFile, { node, className }) {
     suppressLeadingAndTrailingTrivia(node);
     changes.replaceNode(sourceFile, node, factory.createPropertyAccessExpression(className ? factory.createIdentifier(className) : factory.createThis(), node));
   }
-  var fixId30, didYouMeanStaticMemberCode, errorCodes36;
+  var fixId31, didYouMeanStaticMemberCode, errorCodes37;
   var init_fixForgottenThisPropertyAccess = __esm({
     "src/services/codefixes/fixForgottenThisPropertyAccess.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId30 = "forgottenThisPropertyAccess";
+      fixId31 = "forgottenThisPropertyAccess";
       didYouMeanStaticMemberCode = Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code;
-      errorCodes36 = [
+      errorCodes37 = [
         Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
         Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code,
         didYouMeanStaticMemberCode
       ];
       registerCodeFix({
-        errorCodes: errorCodes36,
+        errorCodes: errorCodes37,
         getCodeActions(context) {
           const { sourceFile } = context;
           const info = getInfo9(sourceFile, context.span.start, context.errorCode);
           if (!info) {
             return void 0;
           }
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange15(t, sourceFile, info));
-          return [createCodeFixAction(fixId30, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId30, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, sourceFile, info));
+          return [createCodeFixAction(fixId31, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId31, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)];
         },
-        fixIds: [fixId30],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes36, (changes, diag2) => {
+        fixIds: [fixId31],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes37, (changes, diag2) => {
           const info = getInfo9(diag2.file, diag2.start, diag2.code);
           if (info)
-            doChange15(changes, context.sourceFile, info);
+            doChange17(changes, context.sourceFile, info);
         })
       });
     }
@@ -143411,7 +143674,7 @@ ${lanes.join("\n")}
   function isValidCharacter(character) {
     return hasProperty(htmlEntity, character);
   }
-  function doChange16(changes, preferences, sourceFile, start, useHtmlEntity) {
+  function doChange18(changes, preferences, sourceFile, start, useHtmlEntity) {
     const character = sourceFile.getText()[start];
     if (!isValidCharacter(character)) {
       return;
@@ -143419,7 +143682,7 @@ ${lanes.join("\n")}
     const replacement = useHtmlEntity ? htmlEntity[character] : `{${quote(sourceFile, preferences, character)}}`;
     changes.replaceRangeWithText(sourceFile, { pos: start, end: start + 1 }, replacement);
   }
-  var fixIdExpression, fixIdHtmlEntity, errorCodes37, htmlEntity;
+  var fixIdExpression, fixIdHtmlEntity, errorCodes38, htmlEntity;
   var init_fixInvalidJsxCharacters = __esm({
     "src/services/codefixes/fixInvalidJsxCharacters.ts"() {
       "use strict";
@@ -143427,16 +143690,16 @@ ${lanes.join("\n")}
       init_ts_codefix();
       fixIdExpression = "fixInvalidJsxCharacters_expression";
       fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity";
-      errorCodes37 = [
+      errorCodes38 = [
         Diagnostics.Unexpected_token_Did_you_mean_or_gt.code,
         Diagnostics.Unexpected_token_Did_you_mean_or_rbrace.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes37,
+        errorCodes: errorCodes38,
         fixIds: [fixIdExpression, fixIdHtmlEntity],
         getCodeActions(context) {
           const { sourceFile, preferences, span } = context;
-          const changeToExpression = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(
+          const changeToExpression = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(
             t,
             preferences,
             sourceFile,
@@ -143444,7 +143707,7 @@ ${lanes.join("\n")}
             /* useHtmlEntity */
             false
           ));
-          const changeToHtmlEntity = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(
+          const changeToHtmlEntity = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(
             t,
             preferences,
             sourceFile,
@@ -143458,7 +143721,7 @@ ${lanes.join("\n")}
           ];
         },
         getAllCodeActions(context) {
-          return codeFixAll(context, errorCodes37, (changes, diagnostic) => doChange16(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity));
+          return codeFixAll(context, errorCodes38, (changes, diagnostic) => doChange18(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity));
         }
       });
       htmlEntity = {
@@ -143517,7 +143780,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  var deleteUnmatchedParameter, renameUnmatchedParameter, errorCodes38;
+  var deleteUnmatchedParameter, renameUnmatchedParameter, errorCodes39;
   var init_fixUnmatchedParameter = __esm({
     "src/services/codefixes/fixUnmatchedParameter.ts"() {
       "use strict";
@@ -143525,12 +143788,12 @@ ${lanes.join("\n")}
       init_ts_codefix();
       deleteUnmatchedParameter = "deleteUnmatchedParameter";
       renameUnmatchedParameter = "renameUnmatchedParameter";
-      errorCodes38 = [
+      errorCodes39 = [
         Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code
       ];
       registerCodeFix({
         fixIds: [deleteUnmatchedParameter, renameUnmatchedParameter],
-        errorCodes: errorCodes38,
+        errorCodes: errorCodes39,
         getCodeActions: function getCodeActionsToFixUnmatchedParameter(context) {
           const { sourceFile, span } = context;
           const actions2 = [];
@@ -143545,7 +143808,7 @@ ${lanes.join("\n")}
         getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) {
           const tagsToSignature = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes38, ({ file, start }) => {
+            eachDiagnostic(context, errorCodes39, ({ file, start }) => {
               const info = getInfo10(file, start);
               if (info) {
                 tagsToSignature.set(info.signature, append(tagsToSignature.get(info.signature), info.jsDocParameterTag));
@@ -143594,16 +143857,16 @@ ${lanes.join("\n")}
   function doNamespaceImportChange(changes, sourceFile, importDeclaration, program) {
     ts_refactor_exports.doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, importDeclaration.parent);
   }
-  var fixId31, errorCodes39;
+  var fixId32, errorCodes40;
   var init_fixUnreferenceableDecoratorMetadata = __esm({
     "src/services/codefixes/fixUnreferenceableDecoratorMetadata.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId31 = "fixUnreferenceableDecoratorMetadata";
-      errorCodes39 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code];
+      fixId32 = "fixUnreferenceableDecoratorMetadata";
+      errorCodes40 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code];
       registerCodeFix({
-        errorCodes: errorCodes39,
+        errorCodes: errorCodes40,
         getCodeActions: (context) => {
           const importDeclaration = getImportDeclaration(context.sourceFile, context.program, context.span.start);
           if (!importDeclaration)
@@ -143612,14 +143875,14 @@ ${lanes.join("\n")}
           const typeOnlyChanges = ts_textChanges_exports.ChangeTracker.with(context, (t) => doTypeOnlyImportChange(t, context.sourceFile, importDeclaration, context.program));
           let actions2;
           if (namespaceChanges.length) {
-            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId31, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import));
+            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import));
           }
           if (typeOnlyChanges.length) {
-            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId31, typeOnlyChanges, Diagnostics.Convert_to_type_only_import));
+            actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, typeOnlyChanges, Diagnostics.Convert_to_type_only_import));
           }
           return actions2;
         },
-        fixIds: [fixId31]
+        fixIds: [fixId32]
       });
     }
   });
@@ -143772,7 +144035,7 @@ ${lanes.join("\n")}
   function mayDeleteExpression(node) {
     return (isBinaryExpression(node.parent) && node.parent.left === node || (isPostfixUnaryExpression(node.parent) || isPrefixUnaryExpression(node.parent)) && node.parent.operand === node) && isExpressionStatement(node.parent.parent);
   }
-  var fixName3, fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer, errorCodes40;
+  var fixName3, fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer, errorCodes41;
   var init_fixUnusedIdentifier = __esm({
     "src/services/codefixes/fixUnusedIdentifier.ts"() {
       "use strict";
@@ -143783,7 +144046,7 @@ ${lanes.join("\n")}
       fixIdDelete = "unusedIdentifier_delete";
       fixIdDeleteImports = "unusedIdentifier_deleteImports";
       fixIdInfer = "unusedIdentifier_infer";
-      errorCodes40 = [
+      errorCodes41 = [
         Diagnostics._0_is_declared_but_its_value_is_never_read.code,
         Diagnostics._0_is_declared_but_never_used.code,
         Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code,
@@ -143793,7 +144056,7 @@ ${lanes.join("\n")}
         Diagnostics.All_type_parameters_are_unused.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes40,
+        errorCodes: errorCodes41,
         getCodeActions(context) {
           const { errorCode, sourceFile, program, cancellationToken } = context;
           const checker = program.getTypeChecker();
@@ -143879,7 +144142,7 @@ ${lanes.join("\n")}
           const { sourceFile, program, cancellationToken } = context;
           const checker = program.getTypeChecker();
           const sourceFiles = program.getSourceFiles();
-          return codeFixAll(context, errorCodes40, (changes, diag2) => {
+          return codeFixAll(context, errorCodes41, (changes, diag2) => {
             const token = getTokenAtPosition(sourceFile, diag2.start);
             switch (context.fixId) {
               case fixIdPrefix:
@@ -143951,7 +144214,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixUnreachableCode.ts
-  function doChange17(changes, sourceFile, start, length2, errorCode) {
+  function doChange19(changes, sourceFile, start, length2, errorCode) {
     const token = getTokenAtPosition(sourceFile, start);
     const statement = findAncestor(token, isStatement);
     if (statement.getStart(sourceFile) !== token.getStart(sourceFile)) {
@@ -143999,31 +144262,31 @@ ${lanes.join("\n")}
     }
     return last2;
   }
-  var fixId32, errorCodes41;
+  var fixId33, errorCodes42;
   var init_fixUnreachableCode = __esm({
     "src/services/codefixes/fixUnreachableCode.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId32 = "fixUnreachableCode";
-      errorCodes41 = [Diagnostics.Unreachable_code_detected.code];
+      fixId33 = "fixUnreachableCode";
+      errorCodes42 = [Diagnostics.Unreachable_code_detected.code];
       registerCodeFix({
-        errorCodes: errorCodes41,
+        errorCodes: errorCodes42,
         getCodeActions(context) {
           const syntacticDiagnostics = context.program.getSyntacticDiagnostics(context.sourceFile, context.cancellationToken);
           if (syntacticDiagnostics.length)
             return;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, context.sourceFile, context.span.start, context.span.length, context.errorCode));
-          return [createCodeFixAction(fixId32, changes, Diagnostics.Remove_unreachable_code, fixId32, Diagnostics.Remove_all_unreachable_code)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange19(t, context.sourceFile, context.span.start, context.span.length, context.errorCode));
+          return [createCodeFixAction(fixId33, changes, Diagnostics.Remove_unreachable_code, fixId33, Diagnostics.Remove_all_unreachable_code)];
         },
-        fixIds: [fixId32],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes41, (changes, diag2) => doChange17(changes, diag2.file, diag2.start, diag2.length, diag2.code))
+        fixIds: [fixId33],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes42, (changes, diag2) => doChange19(changes, diag2.file, diag2.start, diag2.length, diag2.code))
       });
     }
   });
 
   // src/services/codefixes/fixUnusedLabel.ts
-  function doChange18(changes, sourceFile, start) {
+  function doChange20(changes, sourceFile, start) {
     const token = getTokenAtPosition(sourceFile, start);
     const labeledStatement = cast(token.parent, isLabeledStatement);
     const pos = token.getStart(sourceFile);
@@ -144036,28 +144299,28 @@ ${lanes.join("\n")}
     );
     changes.deleteRange(sourceFile, { pos, end });
   }
-  var fixId33, errorCodes42;
+  var fixId34, errorCodes43;
   var init_fixUnusedLabel = __esm({
     "src/services/codefixes/fixUnusedLabel.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId33 = "fixUnusedLabel";
-      errorCodes42 = [Diagnostics.Unused_label.code];
+      fixId34 = "fixUnusedLabel";
+      errorCodes43 = [Diagnostics.Unused_label.code];
       registerCodeFix({
-        errorCodes: errorCodes42,
+        errorCodes: errorCodes43,
         getCodeActions(context) {
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(t, context.sourceFile, context.span.start));
-          return [createCodeFixAction(fixId33, changes, Diagnostics.Remove_unused_label, fixId33, Diagnostics.Remove_all_unused_labels)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange20(t, context.sourceFile, context.span.start));
+          return [createCodeFixAction(fixId34, changes, Diagnostics.Remove_unused_label, fixId34, Diagnostics.Remove_all_unused_labels)];
         },
-        fixIds: [fixId33],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes42, (changes, diag2) => doChange18(changes, diag2.file, diag2.start))
+        fixIds: [fixId34],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes43, (changes, diag2) => doChange20(changes, diag2.file, diag2.start))
       });
     }
   });
 
   // src/services/codefixes/fixJSDocTypes.ts
-  function doChange19(changes, sourceFile, oldTypeNode, newType, checker) {
+  function doChange21(changes, sourceFile, oldTypeNode, newType, checker) {
     changes.replaceNode(sourceFile, oldTypeNode, checker.typeToTypeNode(
       newType,
       /*enclosingDeclaration*/
@@ -144106,7 +144369,7 @@ ${lanes.join("\n")}
     }
     return checker.getTypeFromTypeNode(node);
   }
-  var fixIdPlain, fixIdNullable, errorCodes43;
+  var fixIdPlain, fixIdNullable, errorCodes44;
   var init_fixJSDocTypes = __esm({
     "src/services/codefixes/fixJSDocTypes.ts"() {
       "use strict";
@@ -144114,13 +144377,13 @@ ${lanes.join("\n")}
       init_ts_codefix();
       fixIdPlain = "fixJSDocTypes_plain";
       fixIdNullable = "fixJSDocTypes_nullable";
-      errorCodes43 = [
+      errorCodes44 = [
         Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments.code,
         Diagnostics._0_at_the_end_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code,
         Diagnostics._0_at_the_start_of_a_type_is_not_valid_TypeScript_syntax_Did_you_mean_to_write_1.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes43,
+        errorCodes: errorCodes44,
         getCodeActions(context) {
           const { sourceFile } = context;
           const checker = context.program.getTypeChecker();
@@ -144134,22 +144397,22 @@ ${lanes.join("\n")}
             actions2.push(fix(type, fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types));
           }
           return actions2;
-          function fix(type2, fixId51, fixAllDescription) {
-            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange19(t, sourceFile, typeNode, type2, checker));
-            return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId51, fixAllDescription);
+          function fix(type2, fixId52, fixAllDescription) {
+            const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange21(t, sourceFile, typeNode, type2, checker));
+            return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId52, fixAllDescription);
           }
         },
         fixIds: [fixIdPlain, fixIdNullable],
         getAllCodeActions(context) {
-          const { fixId: fixId51, program, sourceFile } = context;
+          const { fixId: fixId52, program, sourceFile } = context;
           const checker = program.getTypeChecker();
-          return codeFixAll(context, errorCodes43, (changes, err) => {
+          return codeFixAll(context, errorCodes44, (changes, err) => {
             const info = getInfo11(err.file, err.start, checker);
             if (!info)
               return;
             const { typeNode, type } = info;
-            const fixedType = typeNode.kind === 317 /* JSDocNullableType */ && fixId51 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
-            doChange19(changes, sourceFile, typeNode, fixedType, checker);
+            const fixedType = typeNode.kind === 317 /* JSDocNullableType */ && fixId52 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
+            doChange21(changes, sourceFile, typeNode, fixedType, checker);
           });
         }
       });
@@ -144157,7 +144420,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixMissingCallParentheses.ts
-  function doChange20(changes, sourceFile, name) {
+  function doChange22(changes, sourceFile, name) {
     changes.replaceNodeWithText(sourceFile, name, `${name.text}()`);
   }
   function getCallName(sourceFile, start) {
@@ -144174,31 +144437,31 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  var fixId34, errorCodes44;
+  var fixId35, errorCodes45;
   var init_fixMissingCallParentheses = __esm({
     "src/services/codefixes/fixMissingCallParentheses.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId34 = "fixMissingCallParentheses";
-      errorCodes44 = [
+      fixId35 = "fixMissingCallParentheses";
+      errorCodes45 = [
         Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes44,
-        fixIds: [fixId34],
+        errorCodes: errorCodes45,
+        fixIds: [fixId35],
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const callName = getCallName(sourceFile, span.start);
           if (!callName)
             return;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange20(t, context.sourceFile, callName));
-          return [createCodeFixAction(fixId34, changes, Diagnostics.Add_missing_call_parentheses, fixId34, Diagnostics.Add_all_missing_call_parentheses)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange22(t, context.sourceFile, callName));
+          return [createCodeFixAction(fixId35, changes, Diagnostics.Add_missing_call_parentheses, fixId35, Diagnostics.Add_all_missing_call_parentheses)];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes44, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes45, (changes, diag2) => {
           const callName = getCallName(diag2.file, diag2.start);
           if (callName)
-            doChange20(changes, diag2.file, callName);
+            doChange22(changes, diag2.file, callName);
         })
       });
     }
@@ -144240,7 +144503,7 @@ ${lanes.join("\n")}
       returnType: getReturnType(containingFunction)
     };
   }
-  function doChange21(changes, sourceFile, { insertBefore, returnType }) {
+  function doChange23(changes, sourceFile, { insertBefore, returnType }) {
     if (returnType) {
       const entityName = getEntityNameFromTypeNode(returnType);
       if (!entityName || entityName.kind !== 79 /* Identifier */ || entityName.text !== "Promise") {
@@ -144249,36 +144512,36 @@ ${lanes.join("\n")}
     }
     changes.insertModifierBefore(sourceFile, 132 /* AsyncKeyword */, insertBefore);
   }
-  var fixId35, errorCodes45;
+  var fixId36, errorCodes46;
   var init_fixAwaitInSyncFunction = __esm({
     "src/services/codefixes/fixAwaitInSyncFunction.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId35 = "fixAwaitInSyncFunction";
-      errorCodes45 = [
+      fixId36 = "fixAwaitInSyncFunction";
+      errorCodes46 = [
         Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
         Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
         Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes45,
+        errorCodes: errorCodes46,
         getCodeActions(context) {
           const { sourceFile, span } = context;
           const nodes = getNodes3(sourceFile, span.start);
           if (!nodes)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange21(t, sourceFile, nodes));
-          return [createCodeFixAction(fixId35, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId35, Diagnostics.Add_all_missing_async_modifiers)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange23(t, sourceFile, nodes));
+          return [createCodeFixAction(fixId36, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId36, Diagnostics.Add_all_missing_async_modifiers)];
         },
-        fixIds: [fixId35],
+        fixIds: [fixId36],
         getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) {
           const seen = /* @__PURE__ */ new Map();
-          return codeFixAll(context, errorCodes45, (changes, diag2) => {
+          return codeFixAll(context, errorCodes46, (changes, diag2) => {
             const nodes = getNodes3(diag2.file, diag2.start);
             if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore)))
               return;
-            doChange21(changes, context.sourceFile, nodes);
+            doChange23(changes, context.sourceFile, nodes);
           });
         }
       });
@@ -144286,7 +144549,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/fixPropertyOverrideAccessor.ts
-  function doChange22(file, start, length2, code, context) {
+  function doChange24(file, start, length2, code, context) {
     let startPosition;
     let endPosition;
     if (code === Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code) {
@@ -144313,28 +144576,28 @@ ${lanes.join("\n")}
     }
     return generateAccessorFromProperty(file, context.program, startPosition, endPosition, context, Diagnostics.Generate_get_and_set_accessors.message);
   }
-  var errorCodes46, fixId36;
+  var errorCodes47, fixId37;
   var init_fixPropertyOverrideAccessor = __esm({
     "src/services/codefixes/fixPropertyOverrideAccessor.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes46 = [
+      errorCodes47 = [
         Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code,
         Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code
       ];
-      fixId36 = "fixPropertyOverrideAccessor";
+      fixId37 = "fixPropertyOverrideAccessor";
       registerCodeFix({
-        errorCodes: errorCodes46,
+        errorCodes: errorCodes47,
         getCodeActions(context) {
-          const edits = doChange22(context.sourceFile, context.span.start, context.span.length, context.errorCode, context);
+          const edits = doChange24(context.sourceFile, context.span.start, context.span.length, context.errorCode, context);
           if (edits) {
-            return [createCodeFixAction(fixId36, edits, Diagnostics.Generate_get_and_set_accessors, fixId36, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
+            return [createCodeFixAction(fixId37, edits, Diagnostics.Generate_get_and_set_accessors, fixId37, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
           }
         },
-        fixIds: [fixId36],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes46, (changes, diag2) => {
-          const edits = doChange22(diag2.file, diag2.start, diag2.length, diag2.code, context);
+        fixIds: [fixId37],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes47, (changes, diag2) => {
+          const edits = doChange24(diag2.file, diag2.start, diag2.length, diag2.code, context);
           if (edits) {
             for (const edit of edits) {
               changes.pushRaw(context.sourceFile, edit);
@@ -144381,7 +144644,7 @@ ${lanes.join("\n")}
     }
     return errorCode;
   }
-  function doChange23(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) {
+  function doChange25(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) {
     if (!isParameterPropertyModifier(token.kind) && token.kind !== 79 /* Identifier */ && token.kind !== 25 /* DotDotDotToken */ && token.kind !== 108 /* ThisKeyword */) {
       return void 0;
     }
@@ -145045,7 +145308,7 @@ ${lanes.join("\n")}
       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 */));
@@ -145275,14 +145538,14 @@ ${lanes.join("\n")}
       }
     }
   }
-  var fixId37, errorCodes47;
+  var fixId38, errorCodes48;
   var init_inferFromUsage = __esm({
     "src/services/codefixes/inferFromUsage.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId37 = "inferFromUsage";
-      errorCodes47 = [
+      fixId38 = "inferFromUsage";
+      errorCodes48 = [
         // Variable declarations
         Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code,
         // Variable uses
@@ -145316,13 +145579,13 @@ ${lanes.join("\n")}
         Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes47,
+        errorCodes: errorCodes48,
         getCodeActions(context) {
           const { sourceFile, program, span: { start }, errorCode, cancellationToken, host, preferences } = context;
           const token = getTokenAtPosition(sourceFile, start);
           let declaration;
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
-            declaration = doChange23(
+            declaration = doChange25(
               changes2,
               sourceFile,
               token,
@@ -145336,14 +145599,14 @@ ${lanes.join("\n")}
             );
           });
           const name = declaration && getNameOfDeclaration(declaration);
-          return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId37, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId37, Diagnostics.Infer_all_types_from_usage)];
+          return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId38, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId38, Diagnostics.Infer_all_types_from_usage)];
         },
-        fixIds: [fixId37],
+        fixIds: [fixId38],
         getAllCodeActions(context) {
           const { sourceFile, program, cancellationToken, host, preferences } = context;
           const markSeen = nodeSeenTracker();
-          return codeFixAll(context, errorCodes47, (changes, err) => {
-            doChange23(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
+          return codeFixAll(context, errorCodes48, (changes, err) => {
+            doChange25(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
           });
         }
       });
@@ -145374,22 +145637,22 @@ ${lanes.join("\n")}
       return { returnTypeNode, returnType, promisedTypeNode, promisedType };
     }
   }
-  function doChange24(changes, sourceFile, returnTypeNode, promisedTypeNode) {
+  function doChange26(changes, sourceFile, returnTypeNode, promisedTypeNode) {
     changes.replaceNode(sourceFile, returnTypeNode, factory.createTypeReferenceNode("Promise", [promisedTypeNode]));
   }
-  var fixId38, errorCodes48;
+  var fixId39, errorCodes49;
   var init_fixReturnTypeInAsyncFunction = __esm({
     "src/services/codefixes/fixReturnTypeInAsyncFunction.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId38 = "fixReturnTypeInAsyncFunction";
-      errorCodes48 = [
+      fixId39 = "fixReturnTypeInAsyncFunction";
+      errorCodes49 = [
         Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes48,
-        fixIds: [fixId38],
+        errorCodes: errorCodes49,
+        fixIds: [fixId39],
         getCodeActions: function getCodeActionsToFixReturnTypeInAsyncFunction(context) {
           const { sourceFile, program, span } = context;
           const checker = program.getTypeChecker();
@@ -145398,23 +145661,23 @@ ${lanes.join("\n")}
             return void 0;
           }
           const { returnTypeNode, returnType, promisedTypeNode, promisedType } = info;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange24(t, sourceFile, returnTypeNode, promisedTypeNode));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange26(t, sourceFile, returnTypeNode, promisedTypeNode));
           return [createCodeFixAction(
-            fixId38,
+            fixId39,
             changes,
             [
               Diagnostics.Replace_0_with_Promise_1,
               checker.typeToString(returnType),
               checker.typeToString(promisedType)
             ],
-            fixId38,
+            fixId39,
             Diagnostics.Fix_all_incorrect_return_type_of_an_async_functions
           )];
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes48, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes49, (changes, diag2) => {
           const info = getInfo12(diag2.file, context.program.getTypeChecker(), diag2.start);
           if (info) {
-            doChange24(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode);
+            doChange26(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode);
           }
         })
       });
@@ -145428,20 +145691,20 @@ ${lanes.join("\n")}
       changes.insertCommentBeforeLine(sourceFile, lineNumber, position, " @ts-ignore");
     }
   }
-  var fixName4, fixId39, errorCodes49;
+  var fixName4, fixId40, errorCodes50;
   var init_disableJsDiagnostics = __esm({
     "src/services/codefixes/disableJsDiagnostics.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixName4 = "disableJsDiagnostics";
-      fixId39 = "disableJsDiagnostics";
-      errorCodes49 = mapDefined(Object.keys(Diagnostics), (key) => {
+      fixId40 = "disableJsDiagnostics";
+      errorCodes50 = mapDefined(Object.keys(Diagnostics), (key) => {
         const diag2 = Diagnostics[key];
         return diag2.category === 1 /* Error */ ? diag2.code : void 0;
       });
       registerCodeFix({
-        errorCodes: errorCodes49,
+        errorCodes: errorCodes50,
         getCodeActions: function getCodeActionsToDisableJsDiagnostics(context) {
           const { sourceFile, program, span, host, formatContext } = context;
           if (!isInJSFile(sourceFile) || !isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) {
@@ -145459,14 +145722,14 @@ ${lanes.join("\n")}
             )
           ];
           if (ts_textChanges_exports.isValidLocationToAddComment(sourceFile, span.start)) {
-            fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId39, Diagnostics.Add_ts_ignore_to_all_error_messages));
+            fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId40, Diagnostics.Add_ts_ignore_to_all_error_messages));
           }
           return fixes;
         },
-        fixIds: [fixId39],
+        fixIds: [fixId40],
         getAllCodeActions: (context) => {
           const seenLines = /* @__PURE__ */ new Set();
-          return codeFixAll(context, errorCodes49, (changes, diag2) => {
+          return codeFixAll(context, errorCodes50, (changes, diag2) => {
             if (ts_textChanges_exports.isValidLocationToAddComment(diag2.file, diag2.start)) {
               makeChange8(changes, diag2.file, diag2.start, seenLines);
             }
@@ -146563,7 +146826,7 @@ ${lanes.join("\n")}
     }
     return void 0;
   }
-  var fixName6, fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer, errorCodes50;
+  var fixName6, fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer, errorCodes51;
   var init_fixStrictClassInitialization = __esm({
     "src/services/codefixes/fixStrictClassInitialization.ts"() {
       "use strict";
@@ -146573,9 +146836,9 @@ ${lanes.join("\n")}
       fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions";
       fixIdAddUndefinedType = "addMissingPropertyUndefinedType";
       fixIdAddInitializer = "addMissingPropertyInitializer";
-      errorCodes50 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
+      errorCodes51 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
       registerCodeFix({
-        errorCodes: errorCodes50,
+        errorCodes: errorCodes51,
         getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) {
           const info = getInfo13(context.sourceFile, context.span.start);
           if (!info)
@@ -146588,7 +146851,7 @@ ${lanes.join("\n")}
         },
         fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes50, (changes, diag2) => {
+          return codeFixAll(context, errorCodes51, (changes, diag2) => {
             const info = getInfo13(diag2.file, diag2.start);
             if (!info)
               return;
@@ -146616,7 +146879,7 @@ ${lanes.join("\n")}
   });
 
   // src/services/codefixes/requireInTs.ts
-  function doChange25(changes, sourceFile, info) {
+  function doChange27(changes, sourceFile, info) {
     const { allowSyntheticDefaults, defaultImportName, namedImports, statement, required } = info;
     changes.replaceNode(sourceFile, statement, defaultImportName && !allowSyntheticDefaults ? factory.createImportEqualsDeclaration(
       /*modifiers*/
@@ -146678,29 +146941,29 @@ ${lanes.join("\n")}
       return factory.createNamedImports(importSpecifiers);
     }
   }
-  var fixId40, errorCodes51;
+  var fixId41, errorCodes52;
   var init_requireInTs = __esm({
     "src/services/codefixes/requireInTs.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId40 = "requireInTs";
-      errorCodes51 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
+      fixId41 = "requireInTs";
+      errorCodes52 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
       registerCodeFix({
-        errorCodes: errorCodes51,
+        errorCodes: errorCodes52,
         getCodeActions(context) {
           const info = getInfo14(context.sourceFile, context.program, context.span.start);
           if (!info) {
             return void 0;
           }
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange25(t, context.sourceFile, info));
-          return [createCodeFixAction(fixId40, changes, Diagnostics.Convert_require_to_import, fixId40, Diagnostics.Convert_all_require_to_import)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange27(t, context.sourceFile, info));
+          return [createCodeFixAction(fixId41, changes, Diagnostics.Convert_require_to_import, fixId41, Diagnostics.Convert_all_require_to_import)];
         },
-        fixIds: [fixId40],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes51, (changes, diag2) => {
+        fixIds: [fixId41],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes52, (changes, diag2) => {
           const info = getInfo14(diag2.file, context.program, diag2.start);
           if (info) {
-            doChange25(changes, context.sourceFile, info);
+            doChange27(changes, context.sourceFile, info);
           }
         })
       });
@@ -146720,7 +146983,7 @@ ${lanes.join("\n")}
       return { importNode, name, moduleSpecifier: importNode.moduleSpecifier };
     }
   }
-  function doChange26(changes, sourceFile, info, preferences) {
+  function doChange28(changes, sourceFile, info, preferences) {
     changes.replaceNode(sourceFile, info.importNode, makeImport(
       info.name,
       /*namedImports*/
@@ -146729,29 +146992,29 @@ ${lanes.join("\n")}
       getQuotePreference(sourceFile, preferences)
     ));
   }
-  var fixId41, errorCodes52;
+  var fixId42, errorCodes53;
   var init_useDefaultImport = __esm({
     "src/services/codefixes/useDefaultImport.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId41 = "useDefaultImport";
-      errorCodes52 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
+      fixId42 = "useDefaultImport";
+      errorCodes53 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
       registerCodeFix({
-        errorCodes: errorCodes52,
+        errorCodes: errorCodes53,
         getCodeActions(context) {
           const { sourceFile, span: { start } } = context;
           const info = getInfo15(sourceFile, start);
           if (!info)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange26(t, sourceFile, info, context.preferences));
-          return [createCodeFixAction(fixId41, changes, Diagnostics.Convert_to_default_import, fixId41, Diagnostics.Convert_all_to_default_imports)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange28(t, sourceFile, info, context.preferences));
+          return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_to_default_import, fixId42, Diagnostics.Convert_all_to_default_imports)];
         },
-        fixIds: [fixId41],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes52, (changes, diag2) => {
+        fixIds: [fixId42],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes53, (changes, diag2) => {
           const info = getInfo15(diag2.file, diag2.start);
           if (info)
-            doChange26(changes, diag2.file, info, context.preferences);
+            doChange28(changes, diag2.file, info, context.preferences);
         })
       });
     }
@@ -146766,27 +147029,27 @@ ${lanes.join("\n")}
     const newText = numericLiteral.getText(sourceFile) + "n";
     changeTracker.replaceNode(sourceFile, numericLiteral, factory.createBigIntLiteral(newText));
   }
-  var fixId42, errorCodes53;
+  var fixId43, errorCodes54;
   var init_useBigintLiteral = __esm({
     "src/services/codefixes/useBigintLiteral.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId42 = "useBigintLiteral";
-      errorCodes53 = [
+      fixId43 = "useBigintLiteral";
+      errorCodes54 = [
         Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes53,
+        errorCodes: errorCodes54,
         getCodeActions: function getCodeActionsToUseBigintLiteral(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange9(t, context.sourceFile, context.span));
           if (changes.length > 0) {
-            return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId42, Diagnostics.Convert_all_to_bigint_numeric_literals)];
+            return [createCodeFixAction(fixId43, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId43, Diagnostics.Convert_all_to_bigint_numeric_literals)];
           }
         },
-        fixIds: [fixId42],
+        fixIds: [fixId43],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes53, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
+          return codeFixAll(context, errorCodes54, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
         }
       });
     }
@@ -146799,7 +147062,7 @@ ${lanes.join("\n")}
     Debug.assert(token.parent.kind === 202 /* ImportType */, "Token parent should be an ImportType");
     return token.parent;
   }
-  function doChange27(changes, sourceFile, importType) {
+  function doChange29(changes, sourceFile, importType) {
     const newTypeNode = factory.updateImportTypeNode(
       importType,
       importType.argument,
@@ -146811,25 +147074,25 @@ ${lanes.join("\n")}
     );
     changes.replaceNode(sourceFile, importType, newTypeNode);
   }
-  var fixIdAddMissingTypeof, fixId43, errorCodes54;
+  var fixIdAddMissingTypeof, fixId44, errorCodes55;
   var init_fixAddModuleReferTypeMissingTypeof = __esm({
     "src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof";
-      fixId43 = fixIdAddMissingTypeof;
-      errorCodes54 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
+      fixId44 = fixIdAddMissingTypeof;
+      errorCodes55 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
       registerCodeFix({
-        errorCodes: errorCodes54,
+        errorCodes: errorCodes55,
         getCodeActions: function getCodeActionsToAddMissingTypeof(context) {
           const { sourceFile, span } = context;
           const importType = getImportTypeNode(sourceFile, span.start);
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange27(t, sourceFile, importType));
-          return [createCodeFixAction(fixId43, changes, Diagnostics.Add_missing_typeof, fixId43, Diagnostics.Add_missing_typeof)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, importType));
+          return [createCodeFixAction(fixId44, changes, Diagnostics.Add_missing_typeof, fixId44, Diagnostics.Add_missing_typeof)];
         },
-        fixIds: [fixId43],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes54, (changes, diag2) => doChange27(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
+        fixIds: [fixId44],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => doChange29(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
       });
     }
   });
@@ -146848,7 +147111,7 @@ ${lanes.join("\n")}
       return void 0;
     return binaryExpr;
   }
-  function doChange28(changeTracker, sf, node) {
+  function doChange30(changeTracker, sf, node) {
     const jsx = flattenInvalidBinaryExpr(node);
     if (jsx)
       changeTracker.replaceNode(sf, node, factory.createJsxFragment(factory.createJsxOpeningFragment(), jsx, factory.createJsxJsxClosingFragment()));
@@ -146871,30 +147134,30 @@ ${lanes.join("\n")}
         return void 0;
     }
   }
-  var fixID2, errorCodes55;
+  var fixID2, errorCodes56;
   var init_wrapJsxInFragment = __esm({
     "src/services/codefixes/wrapJsxInFragment.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixID2 = "wrapJsxInFragment";
-      errorCodes55 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
+      errorCodes56 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
       registerCodeFix({
-        errorCodes: errorCodes55,
+        errorCodes: errorCodes56,
         getCodeActions: function getCodeActionsToWrapJsxInFragment(context) {
           const { sourceFile, span } = context;
           const node = findNodeToFix(sourceFile, span.start);
           if (!node)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange28(t, sourceFile, node));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange30(t, sourceFile, node));
           return [createCodeFixAction(fixID2, changes, Diagnostics.Wrap_in_JSX_fragment, fixID2, Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)];
         },
         fixIds: [fixID2],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => {
           const node = findNodeToFix(context.sourceFile, diag2.start);
           if (!node)
             return void 0;
-          doChange28(changes, context.sourceFile, node);
+          doChange30(changes, context.sourceFile, node);
         })
       });
     }
@@ -146914,7 +147177,7 @@ ${lanes.join("\n")}
   function createTypeAliasFromInterface(declaration, type) {
     return factory.createTypeAliasDeclaration(declaration.modifiers, declaration.name, declaration.typeParameters, type);
   }
-  function doChange29(changes, sourceFile, { indexSignature, container }) {
+  function doChange31(changes, sourceFile, { indexSignature, container }) {
     const members = isInterfaceDeclaration(container) ? container.members : container.type.members;
     const otherMembers = members.filter((member) => !isIndexSignatureDeclaration(member));
     const parameter = first(indexSignature.parameters);
@@ -146941,48 +147204,48 @@ ${lanes.join("\n")}
     ]);
     changes.replaceNode(sourceFile, container, createTypeAliasFromInterface(container, intersectionType));
   }
-  var fixId44, errorCodes56;
+  var fixId45, errorCodes57;
   var init_convertToMappedObjectType = __esm({
     "src/services/codefixes/convertToMappedObjectType.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId44 = "fixConvertToMappedObjectType";
-      errorCodes56 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
+      fixId45 = "fixConvertToMappedObjectType";
+      errorCodes57 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
       registerCodeFix({
-        errorCodes: errorCodes56,
+        errorCodes: errorCodes57,
         getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) {
           const { sourceFile, span } = context;
           const info = getInfo16(sourceFile, span.start);
           if (!info)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, info));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange31(t, sourceFile, info));
           const name = idText(info.container.name);
-          return [createCodeFixAction(fixId44, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId44, [Diagnostics.Convert_0_to_mapped_object_type, name])];
+          return [createCodeFixAction(fixId45, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId45, [Diagnostics.Convert_0_to_mapped_object_type, name])];
         },
-        fixIds: [fixId44],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => {
+        fixIds: [fixId45],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes57, (changes, diag2) => {
           const info = getInfo16(diag2.file, diag2.start);
           if (info)
-            doChange29(changes, diag2.file, info);
+            doChange31(changes, diag2.file, info);
         })
       });
     }
   });
 
   // src/services/codefixes/removeAccidentalCallParentheses.ts
-  var fixId45, errorCodes57;
+  var fixId46, errorCodes58;
   var init_removeAccidentalCallParentheses = __esm({
     "src/services/codefixes/removeAccidentalCallParentheses.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId45 = "removeAccidentalCallParentheses";
-      errorCodes57 = [
+      fixId46 = "removeAccidentalCallParentheses";
+      errorCodes58 = [
         Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes57,
+        errorCodes: errorCodes58,
         getCodeActions(context) {
           const callExpression = findAncestor(getTokenAtPosition(context.sourceFile, context.span.start), isCallExpression);
           if (!callExpression) {
@@ -146991,9 +147254,9 @@ ${lanes.join("\n")}
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
             t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end });
           });
-          return [createCodeFixActionWithoutFixAll(fixId45, changes, Diagnostics.Remove_parentheses)];
+          return [createCodeFixActionWithoutFixAll(fixId46, changes, Diagnostics.Remove_parentheses)];
         },
-        fixIds: [fixId45]
+        fixIds: [fixId46]
       });
     }
   });
@@ -147022,27 +147285,27 @@ ${lanes.join("\n")}
     }
     changeTracker.replaceNode(sourceFile, expressionToReplace, awaitExpression.expression);
   }
-  var fixId46, errorCodes58;
+  var fixId47, errorCodes59;
   var init_removeUnnecessaryAwait = __esm({
     "src/services/codefixes/removeUnnecessaryAwait.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId46 = "removeUnnecessaryAwait";
-      errorCodes58 = [
+      fixId47 = "removeUnnecessaryAwait";
+      errorCodes59 = [
         Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes58,
+        errorCodes: errorCodes59,
         getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span));
           if (changes.length > 0) {
-            return [createCodeFixAction(fixId46, changes, Diagnostics.Remove_unnecessary_await, fixId46, Diagnostics.Remove_all_unnecessary_uses_of_await)];
+            return [createCodeFixAction(fixId47, changes, Diagnostics.Remove_unnecessary_await, fixId47, Diagnostics.Remove_all_unnecessary_uses_of_await)];
           }
         },
-        fixIds: [fixId46],
+        fixIds: [fixId47],
         getAllCodeActions: (context) => {
-          return codeFixAll(context, errorCodes58, (changes, diag2) => makeChange10(changes, diag2.file, diag2));
+          return codeFixAll(context, errorCodes59, (changes, diag2) => makeChange10(changes, diag2.file, diag2));
         }
       });
     }
@@ -147084,26 +147347,26 @@ ${lanes.join("\n")}
       importDeclaration.assertClause
     ));
   }
-  var errorCodes59, fixId47;
+  var errorCodes60, fixId48;
   var init_splitTypeOnlyImport = __esm({
     "src/services/codefixes/splitTypeOnlyImport.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      errorCodes59 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
-      fixId47 = "splitTypeOnlyImport";
+      errorCodes60 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
+      fixId48 = "splitTypeOnlyImport";
       registerCodeFix({
-        errorCodes: errorCodes59,
-        fixIds: [fixId47],
+        errorCodes: errorCodes60,
+        fixIds: [fixId48],
         getCodeActions: function getCodeActionsToSplitTypeOnlyImport(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
             return splitTypeOnlyImport(t, getImportDeclaration2(context.sourceFile, context.span), context);
           });
           if (changes.length) {
-            return [createCodeFixAction(fixId47, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId47, Diagnostics.Split_all_invalid_type_only_imports)];
+            return [createCodeFixAction(fixId48, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId48, Diagnostics.Split_all_invalid_type_only_imports)];
           }
         },
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, error) => {
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes60, (changes, error) => {
           splitTypeOnlyImport(changes, getImportDeclaration2(context.sourceFile, error), context);
         })
       });
@@ -147125,43 +147388,43 @@ ${lanes.join("\n")}
       return;
     return { symbol, token: constToken };
   }
-  function doChange30(changes, sourceFile, token) {
+  function doChange32(changes, sourceFile, token) {
     changes.replaceNode(sourceFile, token, factory.createToken(119 /* LetKeyword */));
   }
-  var fixId48, errorCodes60;
+  var fixId49, errorCodes61;
   var init_convertConstToLet = __esm({
     "src/services/codefixes/convertConstToLet.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId48 = "fixConvertConstToLet";
-      errorCodes60 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
+      fixId49 = "fixConvertConstToLet";
+      errorCodes61 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
       registerCodeFix({
-        errorCodes: errorCodes60,
+        errorCodes: errorCodes61,
         getCodeActions: function getCodeActionsToConvertConstToLet(context) {
           const { sourceFile, span, program } = context;
           const info = getInfo17(sourceFile, span.start, program);
           if (info === void 0)
             return;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange30(t, sourceFile, info.token));
-          return [createCodeFixActionMaybeFixAll(fixId48, changes, Diagnostics.Convert_const_to_let, fixId48, Diagnostics.Convert_all_const_to_let)];
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange32(t, sourceFile, info.token));
+          return [createCodeFixActionMaybeFixAll(fixId49, changes, Diagnostics.Convert_const_to_let, fixId49, Diagnostics.Convert_all_const_to_let)];
         },
         getAllCodeActions: (context) => {
           const { program } = context;
           const seen = /* @__PURE__ */ new Map();
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
-            eachDiagnostic(context, errorCodes60, (diag2) => {
+            eachDiagnostic(context, errorCodes61, (diag2) => {
               const info = getInfo17(diag2.file, diag2.start, program);
               if (info) {
                 if (addToSeen(seen, getSymbolId(info.symbol))) {
-                  return doChange30(changes, diag2.file, info.token);
+                  return doChange32(changes, diag2.file, info.token);
                 }
               }
               return void 0;
             });
           }));
         },
-        fixIds: [fixId48]
+        fixIds: [fixId49]
       });
     }
   });
@@ -147171,40 +147434,40 @@ ${lanes.join("\n")}
     const node = getTokenAtPosition(sourceFile, pos);
     return node.kind === 26 /* SemicolonToken */ && node.parent && (isObjectLiteralExpression(node.parent) || isArrayLiteralExpression(node.parent)) ? { node } : void 0;
   }
-  function doChange31(changes, sourceFile, { node }) {
+  function doChange33(changes, sourceFile, { node }) {
     const newNode = factory.createToken(27 /* CommaToken */);
     changes.replaceNode(sourceFile, node, newNode);
   }
-  var fixId49, expectedErrorCode, errorCodes61;
+  var fixId50, expectedErrorCode, errorCodes62;
   var init_fixExpectedComma = __esm({
     "src/services/codefixes/fixExpectedComma.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
-      fixId49 = "fixExpectedComma";
+      fixId50 = "fixExpectedComma";
       expectedErrorCode = Diagnostics._0_expected.code;
-      errorCodes61 = [expectedErrorCode];
+      errorCodes62 = [expectedErrorCode];
       registerCodeFix({
-        errorCodes: errorCodes61,
+        errorCodes: errorCodes62,
         getCodeActions(context) {
           const { sourceFile } = context;
           const info = getInfo18(sourceFile, context.span.start, context.errorCode);
           if (!info)
             return void 0;
-          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange31(t, sourceFile, info));
+          const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange33(t, sourceFile, info));
           return [createCodeFixAction(
-            fixId49,
+            fixId50,
             changes,
             [Diagnostics.Change_0_to_1, ";", ","],
-            fixId49,
+            fixId50,
             [Diagnostics.Change_0_to_1, ";", ","]
           )];
         },
-        fixIds: [fixId49],
-        getAllCodeActions: (context) => codeFixAll(context, errorCodes61, (changes, diag2) => {
+        fixIds: [fixId50],
+        getAllCodeActions: (context) => codeFixAll(context, errorCodes62, (changes, diag2) => {
           const info = getInfo18(diag2.file, diag2.start, diag2.code);
           if (info)
-            doChange31(changes, context.sourceFile, info);
+            doChange33(changes, context.sourceFile, info);
         })
       });
     }
@@ -147260,29 +147523,29 @@ ${lanes.join("\n")}
       return node.typeArguments;
     }
   }
-  var fixName7, fixId50, errorCodes62;
+  var fixName7, fixId51, errorCodes63;
   var init_fixAddVoidToPromise = __esm({
     "src/services/codefixes/fixAddVoidToPromise.ts"() {
       "use strict";
       init_ts4();
       init_ts_codefix();
       fixName7 = "addVoidToPromise";
-      fixId50 = "addVoidToPromise";
-      errorCodes62 = [
+      fixId51 = "addVoidToPromise";
+      errorCodes63 = [
         Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code,
         Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code
       ];
       registerCodeFix({
-        errorCodes: errorCodes62,
-        fixIds: [fixId50],
+        errorCodes: errorCodes63,
+        fixIds: [fixId51],
         getCodeActions(context) {
           const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span, context.program));
           if (changes.length > 0) {
-            return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId50, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
+            return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId51, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
           }
         },
         getAllCodeActions(context) {
-          return codeFixAll(context, errorCodes62, (changes, diag2) => makeChange11(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
+          return codeFixAll(context, errorCodes63, (changes, diag2) => makeChange11(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
         }
       });
     }
@@ -147317,6 +147580,7 @@ ${lanes.join("\n")}
     getFixes: () => getFixes,
     getImportCompletionAction: () => getImportCompletionAction,
     getImportKind: () => getImportKind,
+    getJSDocTypedefNode: () => getJSDocTypedefNode,
     getNoopSymbolTrackerWithResolver: () => getNoopSymbolTrackerWithResolver,
     getPromoteTypeOnlyCompletionAction: () => getPromoteTypeOnlyCompletionAction,
     getSupportedErrorCodes: () => getSupportedErrorCodes,
@@ -147351,6 +147615,7 @@ ${lanes.join("\n")}
       init_correctQualifiedNameToIndexedAccessType();
       init_convertToTypeOnlyExport();
       init_convertToTypeOnlyImport();
+      init_convertTypedefToType();
       init_convertLiteralTypeToMappedType();
       init_fixClassIncorrectlyImplementsInterface();
       init_importFixes();
@@ -149167,7 +149432,8 @@ ${lanes.join("\n")}
     }
     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
     );
@@ -155779,8 +156045,7 @@ ${lanes.join("\n")}
   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;
@@ -156500,7 +156765,7 @@ ${lanes.join("\n")}
         return void 0;
     }
   }
-  function doChange32(exportingSourceFile, program, info, changes, cancellationToken) {
+  function doChange34(exportingSourceFile, program, info, changes, cancellationToken) {
     changeExport(exportingSourceFile, info, changes, program.getTypeChecker());
     changeImports(program, info, changes, cancellationToken);
   }
@@ -156696,7 +156961,7 @@ ${lanes.join("\n")}
           Debug.assert(actionName2 === defaultToNamedAction.name || actionName2 === namedToDefaultAction.name, "Unexpected action name");
           const info = getInfo19(context);
           Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
-          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange32(context.file, context.program, info, t, context.cancellationToken));
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(context.file, context.program, info, t, context.cancellationToken));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
         }
       });
@@ -156731,7 +156996,7 @@ ${lanes.join("\n")}
   function getShouldUseDefault(program, importClause) {
     return getAllowSyntheticDefaultImports(program.getCompilerOptions()) && isExportEqualsModule(importClause.parent.moduleSpecifier, program.getTypeChecker());
   }
-  function doChange33(sourceFile, program, changes, info) {
+  function doChange35(sourceFile, program, changes, info) {
     const checker = program.getTypeChecker();
     if (info.convertTo === 0 /* Named */) {
       doChangeNamespaceToNamed(sourceFile, checker, changes, info.import, getAllowSyntheticDefaultImports(program.getCompilerOptions()));
@@ -156923,7 +157188,7 @@ ${lanes.join("\n")}
           Debug.assert(some(getOwnValues(actions), (action) => action.name === actionName2), "Unexpected action name");
           const info = getImportConversionInfo(context);
           Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
-          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange33(context.file, context.program, t, info));
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(context.file, context.program, t, info));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
         }
       });
@@ -157265,7 +157530,7 @@ ${lanes.join("\n")}
       afterLast: afterEndNodeIndex === -1 ? void 0 : statements[afterEndNodeIndex]
     };
   }
-  function doChange34(oldFile, program, toMove, changes, host, preferences) {
+  function doChange36(oldFile, program, toMove, changes, host, preferences) {
     const checker = program.getTypeChecker();
     const usage = getUsageInfo(oldFile, toMove.all, checker);
     const currentDirectory = getDirectoryPath(oldFile.fileName);
@@ -158035,7 +158300,7 @@ ${lanes.join("\n")}
         getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName2) {
           Debug.assert(actionName2 === refactorName4, "Wrong refactor invoked");
           const statements = Debug.checkDefined(getStatementsToMove(context));
-          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(context.file, context.program, statements, t, context.host, context.preferences));
+          const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange36(context.file, context.program, statements, t, context.host, context.preferences));
           return { edits, renameFilename: void 0, renameLocation: void 0 };
         }
       });
@@ -158697,12 +158962,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return void 0;
     const groupedReferences = getGroupedReferences(functionDeclaration, program, cancellationToken);
     if (groupedReferences.valid) {
-      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(file, program, host, t, functionDeclaration, groupedReferences));
+      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange37(file, program, host, t, functionDeclaration, groupedReferences));
       return { renameFilename: void 0, renameLocation: void 0, edits };
     }
     return { edits: [] };
   }
-  function doChange35(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
+  function doChange37(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
     const signature = groupedReferences.signature;
     const newFunctionDeclarationParams = map(createNewParameters(functionDeclaration, program, host), (param) => getSynthesizedDeepClone(param));
     if (signature) {
@@ -159495,7 +159760,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
     const edits = ts_textChanges_exports.ChangeTracker.with(
       context,
-      (t) => doChange36(context.file, context.program.getTypeChecker(), t, info, actionName2)
+      (t) => doChange38(context.file, context.program.getTypeChecker(), t, info, actionName2)
     );
     return { edits, renameFilename: void 0, renameLocation: void 0 };
   }
@@ -159651,7 +159916,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return toConvert;
   }
-  function doChange36(sourceFile, checker, changes, info, _actionName) {
+  function doChange38(sourceFile, checker, changes, info, _actionName) {
     const { finalExpression, occurrences, expression } = info;
     const firstOccurrence = occurrences[occurrences.length - 1];
     const convertedChain = convertOccurrences(checker, finalExpression, occurrences);
@@ -161387,7 +161652,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function getRefactorEditsToInferReturnType(context) {
     const info = getInfo21(context);
     if (info && !isRefactorErrorInfo(info)) {
-      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange37(context.file, t, info.declaration, info.returnTypeNode));
+      const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange39(context.file, t, info.declaration, info.returnTypeNode));
       return { renameFilename: void 0, renameLocation: void 0, edits };
     }
     return void 0;
@@ -161412,7 +161677,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return emptyArray;
   }
-  function doChange37(sourceFile, changes, declaration, typeNode) {
+  function doChange39(sourceFile, changes, declaration, typeNode) {
     const closeParen = findChildOfKind(declaration, 21 /* CloseParenToken */, sourceFile);
     const needParens = isArrowFunction(declaration) && closeParen === void 0;
     const endNode2 = needParens ? first(declaration.parameters) : closeParen;
@@ -167869,7 +168134,6 @@ ${options.prefix}` : "\n" : options.prefix
     createTypeChecker: () => createTypeChecker,
     createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
     createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
-    createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
     createUnparsedSourceFile: () => createUnparsedSourceFile,
     createWatchCompilerHost: () => createWatchCompilerHost2,
     createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,
@@ -169280,7 +169544,6 @@ ${options.prefix}` : "\n" : options.prefix
     nodeToDisplayParts: () => nodeToDisplayParts,
     noop: () => noop,
     noopFileWatcher: () => noopFileWatcher,
-    noopPush: () => noopPush,
     normalizePath: () => normalizePath,
     normalizeSlashes: () => normalizeSlashes,
     not: () => not,