typescript 5.5.0-dev.20240430 → 5.5.0-dev.20240501

package/lib/typescript.js

@@ -2362,7 +2362,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240430`;
+var version = `${versionMajorMinor}.0-dev.20240501`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -11330,6 +11330,16 @@ var Diagnostics = {
   Export_0_from_module_1: diag(90059, 3 /* Message */, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"),
   Export_all_referenced_locals: diag(90060, 3 /* Message */, "Export_all_referenced_locals_90060", "Export all referenced locals"),
   Update_modifiers_of_0: diag(90061, 3 /* Message */, "Update_modifiers_of_0_90061", "Update modifiers of '{0}'"),
+  Add_annotation_of_type_0: diag(90062, 3 /* Message */, "Add_annotation_of_type_0_90062", "Add annotation of type '{0}'"),
+  Add_return_type_0: diag(90063, 3 /* Message */, "Add_return_type_0_90063", "Add return type '{0}'"),
+  Extract_base_class_to_variable: diag(90064, 3 /* Message */, "Extract_base_class_to_variable_90064", "Extract base class to variable"),
+  Extract_default_export_to_variable: diag(90065, 3 /* Message */, "Extract_default_export_to_variable_90065", "Extract default export to variable"),
+  Extract_binding_expressions_to_variable: diag(90066, 3 /* Message */, "Extract_binding_expressions_to_variable_90066", "Extract binding expressions to variable"),
+  Add_all_missing_type_annotations: diag(90067, 3 /* Message */, "Add_all_missing_type_annotations_90067", "Add all missing type annotations"),
+  Add_satisfies_and_an_inline_type_assertion_with_0: diag(90068, 3 /* Message */, "Add_satisfies_and_an_inline_type_assertion_with_0_90068", "Add satisfies and an inline type assertion with '{0}'"),
+  Extract_to_variable_and_replace_with_0_as_typeof_0: diag(90069, 3 /* Message */, "Extract_to_variable_and_replace_with_0_as_typeof_0_90069", "Extract to variable and replace with '{0} as typeof {0}'"),
+  Mark_array_literal_as_const: diag(90070, 3 /* Message */, "Mark_array_literal_as_const_90070", "Mark array literal as const"),
+  Annotate_types_of_properties_expando_function_in_a_namespace: diag(90071, 3 /* Message */, "Annotate_types_of_properties_expando_function_in_a_namespace_90071", "Annotate types of properties expando function in a namespace"),
   Convert_function_to_an_ES2015_class: diag(95001, 3 /* Message */, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
   Convert_0_to_1_in_0: diag(95003, 3 /* Message */, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
   Extract_to_0_in_1: diag(95004, 3 /* Message */, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -50243,7 +50253,7 @@ function createTypeChecker(host) {
   var externalHelpersModule;
   var scanner2;
   var Symbol47 = objectAllocator.getSymbolConstructor();
-  var Type28 = objectAllocator.getTypeConstructor();
+  var Type29 = objectAllocator.getTypeConstructor();
   var Signature14 = objectAllocator.getSignatureConstructor();
   var typeCount = 0;
   var symbolCount = 0;
@@ -50385,6 +50395,7 @@ function createTypeChecker(host) {
     getBaseTypes,
     getBaseTypeOfLiteralType,
     getWidenedType,
+    getWidenedLiteralType,
     getTypeFromTypeNode: (nodeIn) => {
       const node = getParseTreeNode(nodeIn, isTypeNode);
       return node ? getTypeFromTypeNode(node) : errorType;
@@ -52962,12 +52973,6 @@ function createTypeChecker(host) {
       }
     }
   }
-  function markConstEnumAliasAsReferenced(symbol) {
-    const links = getSymbolLinks(symbol);
-    if (!links.constEnumReferenced) {
-      links.constEnumReferenced = true;
-    }
-  }
   function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
     if (entityName.kind === 80 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
       entityName = entityName.parent;
@@ -53842,7 +53847,7 @@ function createTypeChecker(host) {
   }
   function createType(flags) {
     var _a;
-    const result = new Type28(checker, flags);
+    const result = new Type29(checker, flags);
     typeCount++;
     result.id = typeCount;
     (_a = tracing) == null ? void 0 : _a.recordType(result);
@@ -53854,7 +53859,7 @@ function createTypeChecker(host) {
     return result;
   }
   function createOriginType(flags) {
-    return new Type28(checker, flags);
+    return new Type29(checker, flags);
   }
   function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */, debugIntrinsicName) {
     checkIntrinsicName(intrinsicName, debugIntrinsicName);
@@ -54452,31 +54457,31 @@ function createTypeChecker(host) {
   }
   function createNodeBuilder() {
     return {
-      typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+      typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
         /*typeNode*/
         void 0
       )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToName(
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToName(
         symbol,
         context,
         meaning,
         /*expectsIdentifier*/
         false
       )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function setTextRange2(context, range, location) {
       if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
@@ -54559,7 +54564,7 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, tracker, cb) {
+    function withContext2(enclosingDeclaration, flags, tracker, cb) {
       Debug.assert(enclosingDeclaration === void 0 || (enclosingDeclaration.flags & 16 /* Synthesized */) === 0);
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
@@ -74352,8 +74357,6 @@ function createTypeChecker(host) {
       ) & (111551 /* Value */ | 1048576 /* ExportValue */)) {
         if (getIsolatedModules(compilerOptions) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) {
           markAliasSymbolAsReferenced(symbol);
-        } else {
-          markConstEnumAliasAsReferenced(symbol);
         }
       }
     }
@@ -75610,60 +75613,71 @@ function createTypeChecker(host) {
     return false;
   }
   function discriminateContextualTypeByObjectMembers(node, contextualType) {
-    return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(
-      contextualType,
-      concatenate(
-        map(
-          filter(node.properties, (p) => {
-            if (!p.symbol) {
+    const key = `D${getNodeId(node)},${getTypeId(contextualType)}`;
+    return getCachedType(key) ?? setCachedType(
+      key,
+      getMatchingUnionConstituentForObjectLiteral(contextualType, node) ?? discriminateTypeByDiscriminableItems(
+        contextualType,
+        concatenate(
+          map(
+            filter(node.properties, (p) => {
+              if (!p.symbol) {
+                return false;
+              }
+              if (p.kind === 303 /* PropertyAssignment */) {
+                return isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName);
+              }
+              if (p.kind === 304 /* ShorthandPropertyAssignment */) {
+                return isDiscriminantProperty(contextualType, p.symbol.escapedName);
+              }
               return false;
-            }
-            if (p.kind === 303 /* PropertyAssignment */) {
-              return isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName);
-            }
-            if (p.kind === 304 /* ShorthandPropertyAssignment */) {
-              return isDiscriminantProperty(contextualType, p.symbol.escapedName);
-            }
-            return false;
-          }),
-          (prop) => [() => getContextFreeTypeOfExpression(prop.kind === 303 /* PropertyAssignment */ ? prop.initializer : prop.name), prop.symbol.escapedName]
+            }),
+            (prop) => [() => getContextFreeTypeOfExpression(prop.kind === 303 /* PropertyAssignment */ ? prop.initializer : prop.name), prop.symbol.escapedName]
+          ),
+          map(
+            filter(getPropertiesOfType(contextualType), (s) => {
+              var _a;
+              return !!(s.flags & 16777216 /* Optional */) && !!((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
+            }),
+            (s) => [() => undefinedType, s.escapedName]
+          )
         ),
-        map(
-          filter(getPropertiesOfType(contextualType), (s) => {
-            var _a;
-            return !!(s.flags & 16777216 /* Optional */) && !!((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
-          }),
-          (s) => [() => undefinedType, s.escapedName]
-        )
-      ),
-      isTypeAssignableTo
+        isTypeAssignableTo
+      )
     );
   }
   function discriminateContextualTypeByJSXAttributes(node, contextualType) {
+    const key = `D${getNodeId(node)},${getTypeId(contextualType)}`;
+    const cached = getCachedType(key);
+    if (cached)
+      return cached;
     const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
-    return discriminateTypeByDiscriminableItems(
-      contextualType,
-      concatenate(
-        map(
-          filter(node.properties, (p) => !!p.symbol && p.kind === 291 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer))),
-          (prop) => [!prop.initializer ? () => trueType : () => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
+    return setCachedType(
+      key,
+      discriminateTypeByDiscriminableItems(
+        contextualType,
+        concatenate(
+          map(
+            filter(node.properties, (p) => !!p.symbol && p.kind === 291 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer))),
+            (prop) => [!prop.initializer ? () => trueType : () => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
+          ),
+          map(
+            filter(getPropertiesOfType(contextualType), (s) => {
+              var _a;
+              if (!(s.flags & 16777216 /* Optional */) || !((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members)) {
+                return false;
+              }
+              const element = node.parent.parent;
+              if (s.escapedName === jsxChildrenPropertyName && isJsxElement(element) && getSemanticJsxChildren(element.children).length) {
+                return false;
+              }
+              return !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
+            }),
+            (s) => [() => undefinedType, s.escapedName]
+          )
         ),
-        map(
-          filter(getPropertiesOfType(contextualType), (s) => {
-            var _a;
-            if (!(s.flags & 16777216 /* Optional */) || !((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members)) {
-              return false;
-            }
-            const element = node.parent.parent;
-            if (s.escapedName === jsxChildrenPropertyName && isJsxElement(element) && getSemanticJsxChildren(element.children).length) {
-              return false;
-            }
-            return !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
-          }),
-          (s) => [() => undefinedType, s.escapedName]
-        )
-      ),
-      isTypeAssignableTo
+        isTypeAssignableTo
+      )
     );
   }
   function getApparentTypeOfContextualType(node, contextFlags) {
@@ -142878,6 +142892,7 @@ __export(ts_refactor_exports, {
   generateGetAccessorAndSetAccessor: () => ts_refactor_generateGetAccessorAndSetAccessor_exports,
   getApplicableRefactors: () => getApplicableRefactors,
   getEditsForRefactor: () => getEditsForRefactor,
+  getIdentifierForNode: () => getIdentifierForNode,
   getNewStatementsAndRemoveFromOldFile: () => getNewStatementsAndRemoveFromOldFile,
   getStatementsToMove: () => getStatementsToMove,
   getTopLevelDeclarationStatement: () => getTopLevelDeclarationStatement,
@@ -144606,6 +144621,15 @@ function refactorKindBeginsWith(known, requested) {
     return true;
   return known.substr(0, requested.length) === requested;
 }
+function getIdentifierForNode(node, scope, checker, file) {
+  return isPropertyAccessExpression(node) && !isClassLike(scope) && !checker.resolveName(
+    node.name.text,
+    node,
+    111551 /* Value */,
+    /*excludeGlobals*/
+    false
+  ) && !isPrivateIdentifier(node.name) && !identifierToKeywordKind(node.name) ? node.name.text : getUniqueName(isClassLike(scope) ? "newProperty" : "newLocal", file);
+}
 function addTargetFileImports(oldFile, importsToCopy, targetFileImportsFromOldFile, checker, program, importAdder) {
   importsToCopy.forEach(([isValidTypeOnlyUseSite, declaration], symbol) => {
     var _a;
@@ -147289,13 +147313,7 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
 function extractConstantInScope(node, scope, { substitutions }, rangeFacts, context) {
   const checker = context.program.getTypeChecker();
   const file = scope.getSourceFile();
-  const localNameText = isPropertyAccessExpression(node) && !isClassLike(scope) && !checker.resolveName(
-    node.name.text,
-    node,
-    111551 /* Value */,
-    /*excludeGlobals*/
-    false
-  ) && !isPrivateIdentifier(node.name) && !identifierToKeywordKind(node.name) ? node.name.text : getUniqueName(isClassLike(scope) ? "newProperty" : "newLocal", file);
+  const localNameText = getIdentifierForNode(node, scope, checker, file);
   const isJS = isInJSFile(scope);
   let variableType = isJS || !checker.isContextSensitive(node) ? void 0 : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NoTruncation */);
   let initializer = transformConstantInitializer(skipParentheses(node), substitutions);
@@ -149863,22 +149881,22 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     }
     return [];
   }
-  function getCodeFixesAtPosition(fileName, start, end, errorCodes66, formatOptions, preferences = emptyOptions) {
+  function getCodeFixesAtPosition(fileName, start, end, errorCodes67, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
     const sourceFile = getValidSourceFile(fileName);
     const span = createTextSpanFromBounds(start, end);
     const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-    return flatMap(deduplicate(errorCodes66, equateValues, compareValues), (errorCode) => {
+    return flatMap(deduplicate(errorCodes67, equateValues, compareValues), (errorCode) => {
       cancellationToken.throwIfCancellationRequested();
       return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
     });
   }
-  function getCombinedCodeFix(scope, fixId53, formatOptions, preferences = emptyOptions) {
+  function getCombinedCodeFix(scope, fixId54, 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: fixId53, sourceFile, program, host, cancellationToken, formatContext, preferences });
+    return ts_codefix_exports.getAllFixes({ fixId: fixId54, sourceFile, program, host, cancellationToken, formatContext, preferences });
   }
   function organizeImports2(args, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
@@ -151557,14 +151575,14 @@ function createCodeFixActionWithoutFixAll(fixName8, changes, description3) {
     void 0
   );
 }
-function createCodeFixAction(fixName8, changes, description3, fixId53, fixAllDescription, command) {
-  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId53, diagnosticToString(fixAllDescription), command);
+function createCodeFixAction(fixName8, changes, description3, fixId54, fixAllDescription, command) {
+  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId54, diagnosticToString(fixAllDescription), command);
 }
-function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId53, fixAllDescription, command) {
-  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId53, fixAllDescription && diagnosticToString(fixAllDescription), command);
+function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId54, fixAllDescription, command) {
+  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId54, fixAllDescription && diagnosticToString(fixAllDescription), command);
 }
-function createCodeFixActionWorker(fixName8, description3, changes, fixId53, fixAllDescription, command) {
-  return { fixName: fixName8, description: description3, changes, fixId: fixId53, fixAllDescription, commands: command ? [command] : void 0 };
+function createCodeFixActionWorker(fixName8, description3, changes, fixId54, fixAllDescription, command) {
+  return { fixName: fixName8, description: description3, changes, fixId: fixId54, fixAllDescription, commands: command ? [command] : void 0 };
 }
 function registerCodeFix(reg) {
   for (const error2 of reg.errorCodes) {
@@ -151572,9 +151590,9 @@ function registerCodeFix(reg) {
     errorCodeToFixes.add(String(error2), reg);
   }
   if (reg.fixIds) {
-    for (const fixId53 of reg.fixIds) {
-      Debug.assert(!fixIdToRegistration.has(fixId53));
-      fixIdToRegistration.set(fixId53, reg);
+    for (const fixId54 of reg.fixIds) {
+      Debug.assert(!fixIdToRegistration.has(fixId54));
+      fixIdToRegistration.set(fixId54, reg);
     }
   }
 }
@@ -151583,17 +151601,17 @@ function getSupportedErrorCodes() {
   return errorCodeToFixesArray ?? (errorCodeToFixesArray = arrayFrom(errorCodeToFixes.keys()));
 }
 function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
-  const { errorCodes: errorCodes66 } = registration;
+  const { errorCodes: errorCodes67 } = registration;
   let maybeFixableDiagnostics = 0;
   for (const diag2 of diagnostics) {
-    if (contains(errorCodes66, diag2.code))
+    if (contains(errorCodes67, diag2.code))
       maybeFixableDiagnostics++;
     if (maybeFixableDiagnostics > 1)
       break;
   }
   const fixAllUnavailable = maybeFixableDiagnostics < 2;
-  return ({ fixId: fixId53, fixAllDescription, ...action }) => {
-    return fixAllUnavailable ? action : { ...action, fixId: fixId53, fixAllDescription };
+  return ({ fixId: fixId54, fixAllDescription, ...action }) => {
+    return fixAllUnavailable ? action : { ...action, fixId: fixId54, fixAllDescription };
   };
 }
 function getFixes(context) {
@@ -151610,24 +151628,30 @@ function createCombinedCodeActions(changes, commands) {
 function createFileTextChanges(fileName, textChanges2) {
   return { fileName, textChanges: textChanges2 };
 }
-function codeFixAll(context, errorCodes66, use) {
+function codeFixAll(context, errorCodes67, use) {
   const commands = [];
-  const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes66, (diag2) => use(t, diag2, commands)));
+  const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes67, (diag2) => use(t, diag2, commands)));
   return createCombinedCodeActions(changes, commands.length === 0 ? void 0 : commands);
 }
-function eachDiagnostic(context, errorCodes66, cb) {
+function eachDiagnostic(context, errorCodes67, cb) {
   for (const diag2 of getDiagnostics(context)) {
-    if (contains(errorCodes66, diag2.code)) {
+    if (contains(errorCodes67, diag2.code)) {
       cb(diag2);
     }
   }
 }
 function getDiagnostics({ program, sourceFile, cancellationToken }) {
-  return [
+  const diagnostics = [
     ...program.getSemanticDiagnostics(sourceFile, cancellationToken),
     ...program.getSyntacticDiagnostics(sourceFile, cancellationToken),
     ...computeSuggestionDiagnostics(sourceFile, program, cancellationToken)
   ];
+  if (getEmitDeclarations(program.getCompilerOptions())) {
+    diagnostics.push(
+      ...program.getDeclarationDiagnostics(sourceFile, cancellationToken)
+    );
+  }
+  return diagnostics;
 }
 
 // src/services/codefixes/addConvertToUnknownForNonOverlappingTypes.ts
@@ -156315,10 +156339,10 @@ registerCodeFix({
     const info = errorCodeFixIdMap[errorCode];
     if (!info)
       return emptyArray;
-    const { descriptions, fixId: fixId53, fixAllDescriptions } = info;
+    const { descriptions, fixId: fixId54, fixAllDescriptions } = info;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start));
     return [
-      createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId53, fixAllDescriptions)
+      createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId54, fixAllDescriptions)
     ];
   },
   fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
@@ -157123,7 +157147,7 @@ registerCodeFix({
   },
   fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes],
   getAllCodeActions: (context) => {
-    const { program, fixId: fixId53 } = context;
+    const { program, fixId: fixId54 } = context;
     const checker = program.getTypeChecker();
     const seen = /* @__PURE__ */ new Map();
     const typeDeclToMembers = /* @__PURE__ */ new Map();
@@ -157133,11 +157157,11 @@ registerCodeFix({
         if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + (info.kind === 3 /* ObjectLiteral */ ? info.identifier : info.token.text))) {
           return;
         }
-        if (fixId53 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
+        if (fixId54 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
           addFunctionDeclaration(changes, context, info);
-        } else if (fixId53 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
+        } else if (fixId54 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
           addObjectLiteralProperties(changes, context, info);
-        } else if (fixId53 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
+        } else if (fixId54 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
           addJsxAttributes(changes, context, info);
         } else {
           if (info.kind === 1 /* Enum */) {
@@ -159059,21 +159083,21 @@ registerCodeFix({
       actions2.push(fix(type, fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types));
     }
     return actions2;
-    function fix(type2, fixId53, fixAllDescription) {
+    function fix(type2, fixId54, fixAllDescription) {
       const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, typeNode, type2, checker));
-      return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId53, fixAllDescription);
+      return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId54, fixAllDescription);
     }
   },
   fixIds: [fixIdPlain, fixIdNullable],
   getAllCodeActions(context) {
-    const { fixId: fixId53, program, sourceFile } = context;
+    const { fixId: fixId54, program, sourceFile } = context;
     const checker = program.getTypeChecker();
     return codeFixAll(context, errorCodes45, (changes, err) => {
       const info = getInfo15(err.file, err.start, checker);
       if (!info)
         return;
       const { typeNode, type } = info;
-      const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId53 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
+      const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId54 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
       doChange29(changes, sourceFile, typeNode, fixedType, checker);
     });
   }
@@ -159168,28 +159192,909 @@ function getCallName(sourceFile, start) {
   return void 0;
 }
 
-// src/services/codefixes/fixAwaitInSyncFunction.ts
-var fixId36 = "fixAwaitInSyncFunction";
+// src/services/codefixes/fixMissingTypeAnnotationOnExports.ts
+var fixId36 = "fixMissingTypeAnnotationOnExports";
+var addAnnotationFix = "add-annotation";
+var addInlineTypeAssertion = "add-type-assertion";
+var extractExpression = "extract-expression";
 var errorCodes47 = [
+  Diagnostics.Function_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code,
+  Diagnostics.Method_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code,
+  Diagnostics.At_least_one_accessor_must_have_an_explicit_return_type_annotation_with_isolatedDeclarations.code,
+  Diagnostics.Variable_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,
+  Diagnostics.Parameter_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,
+  Diagnostics.Property_must_have_an_explicit_type_annotation_with_isolatedDeclarations.code,
+  Diagnostics.Expression_type_can_t_be_inferred_with_isolatedDeclarations.code,
+  Diagnostics.Binding_elements_can_t_be_exported_directly_with_isolatedDeclarations.code,
+  Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations.code,
+  Diagnostics.Enum_member_initializers_must_be_computable_without_references_to_external_symbols_with_isolatedDeclarations.code,
+  Diagnostics.Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations.code,
+  Diagnostics.Objects_that_contain_shorthand_properties_can_t_be_inferred_with_isolatedDeclarations.code,
+  Diagnostics.Objects_that_contain_spread_assignments_can_t_be_inferred_with_isolatedDeclarations.code,
+  Diagnostics.Arrays_with_spread_elements_can_t_inferred_with_isolatedDeclarations.code,
+  Diagnostics.Default_exports_can_t_be_inferred_with_isolatedDeclarations.code,
+  Diagnostics.Only_const_arrays_can_be_inferred_with_isolatedDeclarations.code,
+  Diagnostics.Assigning_properties_to_functions_without_declaring_them_is_not_supported_with_isolatedDeclarations_Add_an_explicit_declaration_for_the_properties_assigned_to_this_function.code,
+  Diagnostics.Declaration_emit_for_this_parameter_requires_implicitly_adding_undefined_to_it_s_type_This_is_not_supported_with_isolatedDeclarations.code,
+  Diagnostics.Add_satisfies_and_a_type_assertion_to_this_expression_satisfies_T_as_T_to_make_the_type_explicit.code
+];
+var canHaveTypeAnnotation = /* @__PURE__ */ new Set([
+  177 /* GetAccessor */,
+  174 /* MethodDeclaration */,
+  172 /* PropertyDeclaration */,
+  262 /* FunctionDeclaration */,
+  218 /* FunctionExpression */,
+  219 /* ArrowFunction */,
+  260 /* VariableDeclaration */,
+  169 /* Parameter */,
+  277 /* ExportAssignment */,
+  263 /* ClassDeclaration */,
+  206 /* ObjectBindingPattern */,
+  207 /* ArrayBindingPattern */
+]);
+var declarationEmitNodeBuilderFlags2 = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */ | 1073741824 /* WriteComputedProps */;
+registerCodeFix({
+  errorCodes: errorCodes47,
+  fixIds: [fixId36],
+  getCodeActions(context) {
+    const fixes = [];
+    addCodeAction(addAnnotationFix, fixes, context, 0 /* Full */, (f) => f.addTypeAnnotation(context.span));
+    addCodeAction(addAnnotationFix, fixes, context, 1 /* Relative */, (f) => f.addTypeAnnotation(context.span));
+    addCodeAction(addAnnotationFix, fixes, context, 2 /* Widened */, (f) => f.addTypeAnnotation(context.span));
+    addCodeAction(addInlineTypeAssertion, fixes, context, 0 /* Full */, (f) => f.addInlineAssertion(context.span));
+    addCodeAction(addInlineTypeAssertion, fixes, context, 1 /* Relative */, (f) => f.addInlineAssertion(context.span));
+    addCodeAction(addAnnotationFix, fixes, context, 2 /* Widened */, (f) => f.addInlineAssertion(context.span));
+    addCodeAction(extractExpression, fixes, context, 0 /* Full */, (f) => f.extractAsVariable(context.span));
+    return fixes;
+  },
+  getAllCodeActions: (context) => {
+    const changes = withContext(context, 0 /* Full */, (f) => {
+      eachDiagnostic(context, errorCodes47, (diag2) => {
+        f.addTypeAnnotation(diag2);
+      });
+    });
+    return createCombinedCodeActions(changes.textChanges);
+  }
+});
+function addCodeAction(fixName8, fixes, context, typePrintMode, cb) {
+  const changes = withContext(context, typePrintMode, cb);
+  if (changes.result && changes.textChanges.length) {
+    fixes.push(createCodeFixAction(
+      fixName8,
+      changes.textChanges,
+      changes.result,
+      fixId36,
+      Diagnostics.Add_all_missing_type_annotations
+    ));
+  }
+}
+function withContext(context, typePrintMode, cb) {
+  const emptyInferenceResult = { typeNode: void 0, mutatedTarget: false };
+  const changeTracker = ts_textChanges_exports.ChangeTracker.fromContext(context);
+  const sourceFile = context.sourceFile;
+  const program = context.program;
+  const typeChecker = program.getTypeChecker();
+  const emitResolver = typeChecker.getEmitResolver();
+  const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
+  const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
+  const fixedNodes = /* @__PURE__ */ new Set();
+  const expandoPropertiesAdded = /* @__PURE__ */ new Set();
+  const typePrinter = createPrinter({
+    preserveSourceNewlines: false
+  });
+  const result = cb({ addTypeAnnotation, addInlineAssertion, extractAsVariable });
+  importAdder.writeFixes(changeTracker);
+  return {
+    result,
+    textChanges: changeTracker.getChanges()
+  };
+  function addTypeAnnotation(span) {
+    const nodeWithDiag = getTokenAtPosition(sourceFile, span.start);
+    const expandoFunction = findExpandoFunction(nodeWithDiag);
+    if (expandoFunction) {
+      if (isFunctionDeclaration(expandoFunction)) {
+        return createNamespaceForExpandoProperties(expandoFunction);
+      }
+      return fixIsolatedDeclarationError(expandoFunction);
+    }
+    const nodeMissingType = findAncestorWithMissingType(nodeWithDiag);
+    if (nodeMissingType) {
+      return fixIsolatedDeclarationError(nodeMissingType);
+    }
+    return void 0;
+  }
+  function createNamespaceForExpandoProperties(expandoFunc) {
+    var _a;
+    if (expandoPropertiesAdded == null ? void 0 : expandoPropertiesAdded.has(expandoFunc))
+      return void 0;
+    expandoPropertiesAdded == null ? void 0 : expandoPropertiesAdded.add(expandoFunc);
+    const type = typeChecker.getTypeAtLocation(expandoFunc);
+    const elements = typeChecker.getPropertiesOfType(type);
+    if (!expandoFunc.name || elements.length === 0)
+      return void 0;
+    const newProperties = [];
+    for (const symbol of elements) {
+      if (!isIdentifierText(symbol.name, getEmitScriptTarget(program.getCompilerOptions())))
+        continue;
+      if (symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration))
+        continue;
+      newProperties.push(factory.createVariableStatement(
+        [factory.createModifier(95 /* ExportKeyword */)],
+        factory.createVariableDeclarationList(
+          [factory.createVariableDeclaration(
+            symbol.name,
+            /*exclamationToken*/
+            void 0,
+            typeToTypeNode2(typeChecker.getTypeOfSymbol(symbol), expandoFunc),
+            /*initializer*/
+            void 0
+          )]
+        )
+      ));
+    }
+    if (newProperties.length === 0)
+      return void 0;
+    const modifiers = [];
+    if ((_a = expandoFunc.modifiers) == null ? void 0 : _a.some((modifier) => modifier.kind === 95 /* ExportKeyword */)) {
+      modifiers.push(factory.createModifier(95 /* ExportKeyword */));
+    }
+    modifiers.push(factory.createModifier(138 /* DeclareKeyword */));
+    const namespace = factory.createModuleDeclaration(
+      modifiers,
+      expandoFunc.name,
+      factory.createModuleBlock(newProperties),
+      /*flags*/
+      32 /* Namespace */ | 128 /* ExportContext */ | 33554432 /* Ambient */ | 101441536 /* ContextFlags */
+    );
+    changeTracker.insertNodeAfter(sourceFile, expandoFunc, namespace);
+    return [Diagnostics.Annotate_types_of_properties_expando_function_in_a_namespace];
+  }
+  function needsParenthesizedExpressionForAssertion(node) {
+    return !isEntityNameExpression(node) && !isCallExpression(node) && !isObjectLiteralExpression(node) && !isArrayLiteralExpression(node);
+  }
+  function createAsExpression(node, type) {
+    if (needsParenthesizedExpressionForAssertion(node)) {
+      node = factory.createParenthesizedExpression(node);
+    }
+    return factory.createAsExpression(node, type);
+  }
+  function createSatisfiesAsExpression(node, type) {
+    if (needsParenthesizedExpressionForAssertion(node)) {
+      node = factory.createParenthesizedExpression(node);
+    }
+    return factory.createAsExpression(factory.createSatisfiesExpression(node, getSynthesizedDeepClone(type)), type);
+  }
+  function addInlineAssertion(span) {
+    const nodeWithDiag = getTokenAtPosition(sourceFile, span.start);
+    const expandoFunction = findExpandoFunction(nodeWithDiag);
+    if (expandoFunction)
+      return;
+    const targetNode = findBestFittingNode(nodeWithDiag, span);
+    if (!targetNode || isValueSignatureDeclaration(targetNode) || isValueSignatureDeclaration(targetNode.parent))
+      return;
+    const isExpressionTarget = isExpression(targetNode);
+    const isShorthandPropertyAssignmentTarget = isShorthandPropertyAssignment(targetNode);
+    if (!isShorthandPropertyAssignmentTarget && isDeclaration(targetNode)) {
+      return void 0;
+    }
+    if (findAncestor(targetNode, isBindingPattern)) {
+      return void 0;
+    }
+    if (findAncestor(targetNode, isEnumMember)) {
+      return void 0;
+    }
+    if (isExpressionTarget && findAncestor(targetNode, isHeritageClause)) {
+      return void 0;
+    }
+    if (isSpreadElement(targetNode)) {
+      return void 0;
+    }
+    const variableDeclaration = findAncestor(targetNode, isVariableDeclaration);
+    const type = variableDeclaration && typeChecker.getTypeAtLocation(variableDeclaration);
+    if (type && type.flags & 8192 /* UniqueESSymbol */) {
+      return void 0;
+    }
+    if (!(isExpressionTarget || isShorthandPropertyAssignmentTarget))
+      return void 0;
+    const { typeNode, mutatedTarget } = inferType(targetNode, type);
+    if (!typeNode || mutatedTarget)
+      return void 0;
+    if (isShorthandPropertyAssignmentTarget) {
+      changeTracker.insertNodeAt(
+        sourceFile,
+        targetNode.end,
+        createAsExpression(
+          getSynthesizedDeepClone(targetNode.name),
+          typeNode
+        ),
+        {
+          prefix: ": "
+        }
+      );
+    } else if (isExpressionTarget) {
+      changeTracker.replaceNode(
+        sourceFile,
+        targetNode,
+        createSatisfiesAsExpression(
+          getSynthesizedDeepClone(targetNode),
+          typeNode
+        )
+      );
+    } else {
+      Debug.assertNever(targetNode);
+    }
+    return [Diagnostics.Add_satisfies_and_an_inline_type_assertion_with_0, typeToStringForDiag(typeNode)];
+  }
+  function extractAsVariable(span) {
+    const nodeWithDiag = getTokenAtPosition(sourceFile, span.start);
+    const targetNode = findBestFittingNode(nodeWithDiag, span);
+    if (!targetNode || isValueSignatureDeclaration(targetNode) || isValueSignatureDeclaration(targetNode.parent))
+      return;
+    const isExpressionTarget = isExpression(targetNode);
+    if (!isExpressionTarget)
+      return;
+    if (isArrayLiteralExpression(targetNode)) {
+      changeTracker.replaceNode(
+        sourceFile,
+        targetNode,
+        createAsExpression(targetNode, factory.createTypeReferenceNode("const"))
+      );
+      return [Diagnostics.Mark_array_literal_as_const];
+    }
+    const parentPropertyAssignment = findAncestor(targetNode, isPropertyAssignment);
+    if (parentPropertyAssignment) {
+      if (parentPropertyAssignment === targetNode.parent && isEntityNameExpression(targetNode))
+        return;
+      const tempName = factory.createUniqueName(
+        getIdentifierForNode(targetNode, sourceFile, typeChecker, sourceFile),
+        16 /* Optimistic */
+      );
+      let replacementTarget = targetNode;
+      let initializationNode = targetNode;
+      if (isSpreadElement(replacementTarget)) {
+        replacementTarget = walkUpParenthesizedExpressions(replacementTarget.parent);
+        if (isConstAssertion2(replacementTarget.parent)) {
+          initializationNode = replacementTarget = replacementTarget.parent;
+        } else {
+          initializationNode = createAsExpression(
+            replacementTarget,
+            factory.createTypeReferenceNode("const")
+          );
+        }
+      }
+      if (isEntityNameExpression(replacementTarget))
+        return void 0;
+      const variableDefinition = factory.createVariableStatement(
+        /*modifiers*/
+        void 0,
+        factory.createVariableDeclarationList([
+          factory.createVariableDeclaration(
+            tempName,
+            /*exclamationToken*/
+            void 0,
+            /*type*/
+            void 0,
+            initializationNode
+          )
+        ], 2 /* Const */)
+      );
+      const statement = findAncestor(targetNode, isStatement);
+      changeTracker.insertNodeBefore(sourceFile, statement, variableDefinition);
+      changeTracker.replaceNode(
+        sourceFile,
+        replacementTarget,
+        factory.createAsExpression(
+          factory.cloneNode(tempName),
+          factory.createTypeQueryNode(
+            factory.cloneNode(tempName)
+          )
+        )
+      );
+      return [Diagnostics.Extract_to_variable_and_replace_with_0_as_typeof_0, typeToStringForDiag(tempName)];
+    }
+  }
+  function findExpandoFunction(node) {
+    const expandoDeclaration = findAncestor(node, (n) => isStatement(n) ? "quit" : isExpandoPropertyDeclaration(n));
+    if (expandoDeclaration && isExpandoPropertyDeclaration(expandoDeclaration)) {
+      let assignmentTarget = expandoDeclaration;
+      if (isBinaryExpression(assignmentTarget)) {
+        assignmentTarget = assignmentTarget.left;
+        if (!isExpandoPropertyDeclaration(assignmentTarget))
+          return void 0;
+      }
+      const targetType = typeChecker.getTypeAtLocation(assignmentTarget.expression);
+      if (!targetType)
+        return;
+      const properties = typeChecker.getPropertiesOfType(targetType);
+      if (some(properties, (p) => p.valueDeclaration === expandoDeclaration || p.valueDeclaration === expandoDeclaration.parent)) {
+        const fn = targetType.symbol.valueDeclaration;
+        if (fn) {
+          if (isFunctionExpressionOrArrowFunction(fn) && isVariableDeclaration(fn.parent)) {
+            return fn.parent;
+          }
+          if (isFunctionDeclaration(fn)) {
+            return fn;
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  function fixIsolatedDeclarationError(node) {
+    if (fixedNodes == null ? void 0 : fixedNodes.has(node))
+      return void 0;
+    fixedNodes == null ? void 0 : fixedNodes.add(node);
+    switch (node.kind) {
+      case 169 /* Parameter */:
+      case 172 /* PropertyDeclaration */:
+      case 260 /* VariableDeclaration */:
+        return addTypeToVariableLike(node);
+      case 219 /* ArrowFunction */:
+      case 218 /* FunctionExpression */:
+      case 262 /* FunctionDeclaration */:
+      case 174 /* MethodDeclaration */:
+      case 177 /* GetAccessor */:
+        return addTypeToSignatureDeclaration(node, sourceFile);
+      case 277 /* ExportAssignment */:
+        return transformExportAssignment(node);
+      case 263 /* ClassDeclaration */:
+        return transformExtendsClauseWithExpression(node);
+      case 206 /* ObjectBindingPattern */:
+      case 207 /* ArrayBindingPattern */:
+        return transformDestructuringPatterns(node);
+      default:
+        throw new Error(`Cannot find a fix for the given node ${node.kind}`);
+    }
+  }
+  function addTypeToSignatureDeclaration(func, sourceFile2) {
+    if (func.type) {
+      return;
+    }
+    const { typeNode } = inferType(func);
+    if (typeNode) {
+      changeTracker.tryInsertTypeAnnotation(
+        sourceFile2,
+        func,
+        typeNode
+      );
+      return [Diagnostics.Add_return_type_0, typeToStringForDiag(typeNode)];
+    }
+  }
+  function transformExportAssignment(defaultExport) {
+    if (defaultExport.isExportEquals) {
+      return;
+    }
+    const { typeNode } = inferType(defaultExport.expression);
+    if (!typeNode)
+      return void 0;
+    const defaultIdentifier = factory.createUniqueName("_default");
+    changeTracker.replaceNodeWithNodes(sourceFile, defaultExport, [
+      factory.createVariableStatement(
+        /*modifiers*/
+        void 0,
+        factory.createVariableDeclarationList(
+          [factory.createVariableDeclaration(
+            defaultIdentifier,
+            /*exclamationToken*/
+            void 0,
+            typeNode,
+            defaultExport.expression
+          )],
+          2 /* Const */
+        )
+      ),
+      factory.updateExportAssignment(defaultExport, defaultExport == null ? void 0 : defaultExport.modifiers, defaultIdentifier)
+    ]);
+    return [
+      Diagnostics.Extract_default_export_to_variable
+    ];
+  }
+  function transformExtendsClauseWithExpression(classDecl) {
+    var _a, _b;
+    const extendsClause = (_a = classDecl.heritageClauses) == null ? void 0 : _a.find((p) => p.token === 96 /* ExtendsKeyword */);
+    const heritageExpression = extendsClause == null ? void 0 : extendsClause.types[0];
+    if (!heritageExpression) {
+      return void 0;
+    }
+    const { typeNode: heritageTypeNode } = inferType(heritageExpression.expression);
+    if (!heritageTypeNode) {
+      return void 0;
+    }
+    const baseClassName = factory.createUniqueName(
+      classDecl.name ? classDecl.name.text + "Base" : "Anonymous",
+      16 /* Optimistic */
+    );
+    const heritageVariable = factory.createVariableStatement(
+      /*modifiers*/
+      void 0,
+      factory.createVariableDeclarationList(
+        [factory.createVariableDeclaration(
+          baseClassName,
+          /*exclamationToken*/
+          void 0,
+          heritageTypeNode,
+          heritageExpression.expression
+        )],
+        2 /* Const */
+      )
+    );
+    changeTracker.insertNodeBefore(sourceFile, classDecl, heritageVariable);
+    const trailingComments = getTrailingCommentRanges(sourceFile.text, heritageExpression.end);
+    const realEnd = ((_b = trailingComments == null ? void 0 : trailingComments[trailingComments.length - 1]) == null ? void 0 : _b.end) ?? heritageExpression.end;
+    changeTracker.replaceRange(
+      sourceFile,
+      {
+        pos: heritageExpression.getFullStart(),
+        end: realEnd
+      },
+      baseClassName,
+      {
+        prefix: " "
+      }
+    );
+    return [Diagnostics.Extract_base_class_to_variable];
+  }
+  let ExpressionType;
+  ((ExpressionType2) => {
+    ExpressionType2[ExpressionType2["Text"] = 0] = "Text";
+    ExpressionType2[ExpressionType2["Computed"] = 1] = "Computed";
+    ExpressionType2[ExpressionType2["ArrayAccess"] = 2] = "ArrayAccess";
+    ExpressionType2[ExpressionType2["Identifier"] = 3] = "Identifier";
+  })(ExpressionType || (ExpressionType = {}));
+  function transformDestructuringPatterns(bindingPattern) {
+    var _a;
+    const enclosingVariableDeclaration = bindingPattern.parent;
+    const enclosingVarStmt = bindingPattern.parent.parent.parent;
+    if (!enclosingVariableDeclaration.initializer)
+      return void 0;
+    let baseExpr;
+    const newNodes = [];
+    if (!isIdentifier(enclosingVariableDeclaration.initializer)) {
+      const tempHolderForReturn = factory.createUniqueName("dest", 16 /* Optimistic */);
+      baseExpr = { expression: { kind: 3 /* Identifier */, identifier: tempHolderForReturn } };
+      newNodes.push(factory.createVariableStatement(
+        /*modifiers*/
+        void 0,
+        factory.createVariableDeclarationList(
+          [factory.createVariableDeclaration(
+            tempHolderForReturn,
+            /*exclamationToken*/
+            void 0,
+            /*type*/
+            void 0,
+            enclosingVariableDeclaration.initializer
+          )],
+          2 /* Const */
+        )
+      ));
+    } else {
+      baseExpr = { expression: { kind: 3 /* Identifier */, identifier: enclosingVariableDeclaration.initializer } };
+    }
+    const bindingElements = [];
+    if (isArrayBindingPattern(bindingPattern)) {
+      addArrayBindingPatterns(bindingPattern, bindingElements, baseExpr);
+    } else {
+      addObjectBindingPatterns(bindingPattern, bindingElements, baseExpr);
+    }
+    const expressionToVar = /* @__PURE__ */ new Map();
+    for (const bindingElement of bindingElements) {
+      if (bindingElement.element.propertyName && isComputedPropertyName(bindingElement.element.propertyName)) {
+        const computedExpression = bindingElement.element.propertyName.expression;
+        const identifierForComputedProperty = factory.getGeneratedNameForNode(computedExpression);
+        const variableDecl = factory.createVariableDeclaration(
+          identifierForComputedProperty,
+          /*exclamationToken*/
+          void 0,
+          /*type*/
+          void 0,
+          computedExpression
+        );
+        const variableList = factory.createVariableDeclarationList([variableDecl], 2 /* Const */);
+        const variableStatement = factory.createVariableStatement(
+          /*modifiers*/
+          void 0,
+          variableList
+        );
+        newNodes.push(variableStatement);
+        expressionToVar.set(computedExpression, identifierForComputedProperty);
+      }
+      const name = bindingElement.element.name;
+      if (isArrayBindingPattern(name)) {
+        addArrayBindingPatterns(name, bindingElements, bindingElement);
+      } else if (isObjectBindingPattern(name)) {
+        addObjectBindingPatterns(name, bindingElements, bindingElement);
+      } else {
+        const { typeNode } = inferType(name);
+        let variableInitializer = createChainedExpression(bindingElement, expressionToVar);
+        if (bindingElement.element.initializer) {
+          const propertyName = (_a = bindingElement.element) == null ? void 0 : _a.propertyName;
+          const tempName = factory.createUniqueName(
+            propertyName && isIdentifier(propertyName) ? propertyName.text : "temp",
+            16 /* Optimistic */
+          );
+          newNodes.push(factory.createVariableStatement(
+            /*modifiers*/
+            void 0,
+            factory.createVariableDeclarationList(
+              [factory.createVariableDeclaration(
+                tempName,
+                /*exclamationToken*/
+                void 0,
+                /*type*/
+                void 0,
+                variableInitializer
+              )],
+              2 /* Const */
+            )
+          ));
+          variableInitializer = factory.createConditionalExpression(
+            factory.createBinaryExpression(
+              tempName,
+              factory.createToken(37 /* EqualsEqualsEqualsToken */),
+              factory.createIdentifier("undefined")
+            ),
+            factory.createToken(58 /* QuestionToken */),
+            bindingElement.element.initializer,
+            factory.createToken(59 /* ColonToken */),
+            variableInitializer
+          );
+        }
+        const exportModifier = hasSyntacticModifier(enclosingVarStmt, 32 /* Export */) ? [factory.createToken(95 /* ExportKeyword */)] : void 0;
+        newNodes.push(factory.createVariableStatement(
+          exportModifier,
+          factory.createVariableDeclarationList(
+            [factory.createVariableDeclaration(
+              name,
+              /*exclamationToken*/
+              void 0,
+              typeNode,
+              variableInitializer
+            )],
+            2 /* Const */
+          )
+        ));
+      }
+    }
+    if (enclosingVarStmt.declarationList.declarations.length > 1) {
+      newNodes.push(factory.updateVariableStatement(
+        enclosingVarStmt,
+        enclosingVarStmt.modifiers,
+        factory.updateVariableDeclarationList(
+          enclosingVarStmt.declarationList,
+          enclosingVarStmt.declarationList.declarations.filter((node) => node !== bindingPattern.parent)
+        )
+      ));
+    }
+    changeTracker.replaceNodeWithNodes(sourceFile, enclosingVarStmt, newNodes);
+    return [
+      Diagnostics.Extract_binding_expressions_to_variable
+    ];
+  }
+  function addArrayBindingPatterns(bindingPattern, bindingElements, parent2) {
+    for (let i = 0; i < bindingPattern.elements.length; ++i) {
+      const element = bindingPattern.elements[i];
+      if (isOmittedExpression(element)) {
+        continue;
+      }
+      bindingElements.push({
+        element,
+        parent: parent2,
+        expression: { kind: 2 /* ArrayAccess */, arrayIndex: i }
+      });
+    }
+  }
+  function addObjectBindingPatterns(bindingPattern, bindingElements, parent2) {
+    for (const bindingElement of bindingPattern.elements) {
+      let name;
+      if (bindingElement.propertyName) {
+        if (isComputedPropertyName(bindingElement.propertyName)) {
+          bindingElements.push({
+            element: bindingElement,
+            parent: parent2,
+            expression: { kind: 1 /* Computed */, computed: bindingElement.propertyName.expression }
+          });
+          continue;
+        } else {
+          name = bindingElement.propertyName.text;
+        }
+      } else {
+        name = bindingElement.name.text;
+      }
+      bindingElements.push({
+        element: bindingElement,
+        parent: parent2,
+        expression: { kind: 0 /* Text */, text: name }
+      });
+    }
+  }
+  function createChainedExpression(expression, expressionToVar) {
+    const reverseTraverse = [expression];
+    while (expression.parent) {
+      expression = expression.parent;
+      reverseTraverse.push(expression);
+    }
+    let chainedExpression = reverseTraverse[reverseTraverse.length - 1].expression.identifier;
+    for (let i = reverseTraverse.length - 2; i >= 0; --i) {
+      const nextSubExpr = reverseTraverse[i].expression;
+      if (nextSubExpr.kind === 0 /* Text */) {
+        chainedExpression = factory.createPropertyAccessChain(
+          chainedExpression,
+          /*questionDotToken*/
+          void 0,
+          factory.createIdentifier(nextSubExpr.text)
+        );
+      } else if (nextSubExpr.kind === 1 /* Computed */) {
+        chainedExpression = factory.createElementAccessExpression(
+          chainedExpression,
+          expressionToVar.get(nextSubExpr.computed)
+        );
+      } else if (nextSubExpr.kind === 2 /* ArrayAccess */) {
+        chainedExpression = factory.createElementAccessExpression(
+          chainedExpression,
+          nextSubExpr.arrayIndex
+        );
+      }
+    }
+    return chainedExpression;
+  }
+  function inferType(node, variableType) {
+    if (typePrintMode === 1 /* Relative */) {
+      return relativeType(node);
+    }
+    let type = isValueSignatureDeclaration(node) ? tryGetReturnType2(node) : typeChecker.getTypeAtLocation(node);
+    if (!type) {
+      return emptyInferenceResult;
+    }
+    if (typePrintMode === 2 /* Widened */) {
+      if (variableType) {
+        type = variableType;
+      }
+      const widenedType = typeChecker.getWidenedLiteralType(type);
+      if (typeChecker.isTypeAssignableTo(widenedType, type)) {
+        return emptyInferenceResult;
+      }
+      type = widenedType;
+    }
+    if (isParameter(node) && emitResolver.requiresAddingImplicitUndefined(node)) {
+      type = typeChecker.getUnionType([typeChecker.getUndefinedType(), type], 0 /* None */);
+    }
+    const flags = (isVariableDeclaration(node) || isPropertyDeclaration(node) && hasSyntacticModifier(node, 256 /* Static */ | 8 /* Readonly */)) && type.flags & 8192 /* UniqueESSymbol */ ? 1048576 /* AllowUniqueESSymbolType */ : 0 /* None */;
+    return {
+      typeNode: typeToTypeNode2(type, findAncestor(node, isDeclaration) ?? sourceFile, flags),
+      mutatedTarget: false
+    };
+  }
+  function createTypeOfFromEntityNameExpression(node) {
+    return factory.createTypeQueryNode(getSynthesizedDeepClone(node));
+  }
+  function typeFromArraySpreadElements(node, name = "temp") {
+    const isConstContext = !!findAncestor(node, isConstAssertion2);
+    if (!isConstContext)
+      return emptyInferenceResult;
+    return typeFromSpreads(
+      node,
+      name,
+      isConstContext,
+      (n) => n.elements,
+      isSpreadElement,
+      factory.createSpreadElement,
+      (props) => factory.createArrayLiteralExpression(
+        props,
+        /*multiLine*/
+        true
+      ),
+      (types) => factory.createTupleTypeNode(types.map(factory.createRestTypeNode))
+    );
+  }
+  function typeFromObjectSpreadAssignment(node, name = "temp") {
+    const isConstContext = !!findAncestor(node, isConstAssertion2);
+    return typeFromSpreads(
+      node,
+      name,
+      isConstContext,
+      (n) => n.properties,
+      isSpreadAssignment,
+      factory.createSpreadAssignment,
+      (props) => factory.createObjectLiteralExpression(
+        props,
+        /*multiLine*/
+        true
+      ),
+      factory.createIntersectionTypeNode
+    );
+  }
+  function typeFromSpreads(node, name, isConstContext, getChildren, isSpread, createSpread, makeNodeOfKind, finalType) {
+    const intersectionTypes = [];
+    const newSpreads = [];
+    let currentVariableProperties;
+    const statement = findAncestor(node, isStatement);
+    for (const prop of getChildren(node)) {
+      if (isSpread(prop)) {
+        finalizesVariablePart();
+        if (isEntityNameExpression(prop.expression)) {
+          intersectionTypes.push(createTypeOfFromEntityNameExpression(prop.expression));
+          newSpreads.push(prop);
+        } else {
+          makeVariable(prop.expression);
+        }
+      } else {
+        (currentVariableProperties ?? (currentVariableProperties = [])).push(prop);
+      }
+    }
+    if (newSpreads.length === 0) {
+      return emptyInferenceResult;
+    }
+    finalizesVariablePart();
+    changeTracker.replaceNode(sourceFile, node, makeNodeOfKind(newSpreads));
+    return {
+      typeNode: finalType(intersectionTypes),
+      mutatedTarget: true
+    };
+    function makeVariable(expression) {
+      const tempName = factory.createUniqueName(
+        name + "_Part" + (newSpreads.length + 1),
+        16 /* Optimistic */
+      );
+      const initializer = !isConstContext ? expression : factory.createAsExpression(
+        expression,
+        factory.createTypeReferenceNode("const")
+      );
+      const variableDefinition = factory.createVariableStatement(
+        /*modifiers*/
+        void 0,
+        factory.createVariableDeclarationList([
+          factory.createVariableDeclaration(
+            tempName,
+            /*exclamationToken*/
+            void 0,
+            /*type*/
+            void 0,
+            initializer
+          )
+        ], 2 /* Const */)
+      );
+      changeTracker.insertNodeBefore(sourceFile, statement, variableDefinition);
+      intersectionTypes.push(createTypeOfFromEntityNameExpression(tempName));
+      newSpreads.push(createSpread(tempName));
+    }
+    function finalizesVariablePart() {
+      if (currentVariableProperties) {
+        makeVariable(makeNodeOfKind(
+          currentVariableProperties
+        ));
+        currentVariableProperties = void 0;
+      }
+    }
+  }
+  function isConstAssertion2(location) {
+    return isAssertionExpression(location) && isConstTypeReference(location.type);
+  }
+  function relativeType(node) {
+    if (isParameter(node)) {
+      return emptyInferenceResult;
+    }
+    if (isShorthandPropertyAssignment(node)) {
+      return {
+        typeNode: createTypeOfFromEntityNameExpression(node.name),
+        mutatedTarget: false
+      };
+    }
+    if (isEntityNameExpression(node)) {
+      return {
+        typeNode: createTypeOfFromEntityNameExpression(node),
+        mutatedTarget: false
+      };
+    }
+    if (isConstAssertion2(node)) {
+      return relativeType(node.expression);
+    }
+    if (isArrayLiteralExpression(node)) {
+      const variableDecl = findAncestor(node, isVariableDeclaration);
+      const partName = variableDecl && isIdentifier(variableDecl.name) ? variableDecl.name.text : void 0;
+      return typeFromArraySpreadElements(node, partName);
+    }
+    if (isObjectLiteralExpression(node)) {
+      const variableDecl = findAncestor(node, isVariableDeclaration);
+      const partName = variableDecl && isIdentifier(variableDecl.name) ? variableDecl.name.text : void 0;
+      return typeFromObjectSpreadAssignment(node, partName);
+    }
+    if (isVariableDeclaration(node) && node.initializer) {
+      return relativeType(node.initializer);
+    }
+    if (isConditionalExpression(node)) {
+      const { typeNode: trueType, mutatedTarget: mTrue } = relativeType(node.whenTrue);
+      if (!trueType)
+        return emptyInferenceResult;
+      const { typeNode: falseType, mutatedTarget: mFalse } = relativeType(node.whenFalse);
+      if (!falseType)
+        return emptyInferenceResult;
+      return {
+        typeNode: factory.createUnionTypeNode([trueType, falseType]),
+        mutatedTarget: mTrue || mFalse
+      };
+    }
+    return emptyInferenceResult;
+  }
+  function typeToTypeNode2(type, enclosingDeclaration, flags = 0 /* None */) {
+    let isTruncated = false;
+    const result2 = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, {
+      moduleResolverHost: program,
+      trackSymbol() {
+        return true;
+      },
+      reportTruncationError() {
+        isTruncated = true;
+      }
+    });
+    return isTruncated ? factory.createKeywordTypeNode(133 /* AnyKeyword */) : result2;
+  }
+  function tryGetReturnType2(node) {
+    const signature = typeChecker.getSignatureFromDeclaration(node);
+    if (signature) {
+      return typeChecker.getReturnTypeOfSignature(signature);
+    }
+  }
+  function addTypeToVariableLike(decl) {
+    const { typeNode } = inferType(decl);
+    if (typeNode) {
+      if (decl.type) {
+        changeTracker.replaceNode(getSourceFileOfNode(decl), decl.type, typeNode);
+      } else {
+        changeTracker.tryInsertTypeAnnotation(getSourceFileOfNode(decl), decl, typeNode);
+      }
+      return [Diagnostics.Add_annotation_of_type_0, typeToStringForDiag(typeNode)];
+    }
+  }
+  function typeToStringForDiag(node) {
+    setEmitFlags(node, 1 /* SingleLine */);
+    const result2 = typePrinter.printNode(4 /* Unspecified */, node, sourceFile);
+    if (result2.length > defaultMaximumTruncationLength) {
+      return result2.substring(0, defaultMaximumTruncationLength - "...".length) + "...";
+    }
+    setEmitFlags(node, 0 /* None */);
+    return result2;
+  }
+}
+function findAncestorWithMissingType(node) {
+  return findAncestor(node, (n) => {
+    return canHaveTypeAnnotation.has(n.kind) && (!isObjectBindingPattern(n) && !isArrayBindingPattern(n) || isVariableDeclaration(n.parent));
+  });
+}
+function findBestFittingNode(node, span) {
+  while (node && node.end < span.start + span.length) {
+    node = node.parent;
+  }
+  while (node.parent.pos === node.pos && node.parent.end === node.end) {
+    node = node.parent;
+  }
+  if (isIdentifier(node) && hasInitializer(node.parent) && node.parent.initializer) {
+    return node.parent.initializer;
+  }
+  return node;
+}
+
+// src/services/codefixes/fixAwaitInSyncFunction.ts
+var fixId37 = "fixAwaitInSyncFunction";
+var errorCodes48 = [
   Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
   Diagnostics.await_using_statements_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: errorCodes47,
+  errorCodes: errorCodes48,
   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) => doChange31(t, sourceFile, nodes));
-    return [createCodeFixAction(fixId36, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId36, Diagnostics.Add_all_missing_async_modifiers)];
+    return [createCodeFixAction(fixId37, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId37, Diagnostics.Add_all_missing_async_modifiers)];
   },
-  fixIds: [fixId36],
+  fixIds: [fixId37],
   getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) {
     const seen = /* @__PURE__ */ new Map();
-    return codeFixAll(context, errorCodes47, (changes, diag2) => {
+    return codeFixAll(context, errorCodes48, (changes, diag2) => {
       const nodes = getNodes3(diag2.file, diag2.start);
       if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore)))
         return;
@@ -159243,21 +160148,21 @@ function doChange31(changes, sourceFile, { insertBefore, returnType }) {
 }
 
 // src/services/codefixes/fixPropertyOverrideAccessor.ts
-var errorCodes48 = [
+var errorCodes49 = [
   Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code,
   Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code
 ];
-var fixId37 = "fixPropertyOverrideAccessor";
+var fixId38 = "fixPropertyOverrideAccessor";
 registerCodeFix({
-  errorCodes: errorCodes48,
+  errorCodes: errorCodes49,
   getCodeActions(context) {
     const edits = doChange32(context.sourceFile, context.span.start, context.span.length, context.errorCode, context);
     if (edits) {
-      return [createCodeFixAction(fixId37, edits, Diagnostics.Generate_get_and_set_accessors, fixId37, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
+      return [createCodeFixAction(fixId38, edits, Diagnostics.Generate_get_and_set_accessors, fixId38, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
     }
   },
-  fixIds: [fixId37],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes48, (changes, diag2) => {
+  fixIds: [fixId38],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes49, (changes, diag2) => {
     const edits = doChange32(diag2.file, diag2.start, diag2.length, diag2.code, context);
     if (edits) {
       for (const edit of edits) {
@@ -159295,8 +160200,8 @@ function doChange32(file, start, length2, code, context) {
 }
 
 // src/services/codefixes/inferFromUsage.ts
-var fixId38 = "inferFromUsage";
-var errorCodes49 = [
+var fixId39 = "inferFromUsage";
+var errorCodes50 = [
   // Variable declarations
   Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code,
   // Variable uses
@@ -159330,7 +160235,7 @@ var errorCodes49 = [
   Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes49,
+  errorCodes: errorCodes50,
   getCodeActions(context) {
     const { sourceFile, program, span: { start }, errorCode, cancellationToken, host, preferences } = context;
     const token = getTokenAtPosition(sourceFile, start);
@@ -159350,13 +160255,13 @@ registerCodeFix({
       );
     });
     const name = declaration && getNameOfDeclaration(declaration);
-    return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId38, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId38, Diagnostics.Infer_all_types_from_usage)];
+    return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId39, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId39, Diagnostics.Infer_all_types_from_usage)];
   },
-  fixIds: [fixId38],
+  fixIds: [fixId39],
   getAllCodeActions(context) {
     const { sourceFile, program, cancellationToken, host, preferences } = context;
     const markSeen = nodeSeenTracker();
-    return codeFixAll(context, errorCodes49, (changes, err) => {
+    return codeFixAll(context, errorCodes50, (changes, err) => {
       doChange33(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
     });
   }
@@ -160295,13 +161200,13 @@ function inferTypeFromReferences(program, references, cancellationToken) {
 }
 
 // src/services/codefixes/fixReturnTypeInAsyncFunction.ts
-var fixId39 = "fixReturnTypeInAsyncFunction";
-var errorCodes50 = [
+var fixId40 = "fixReturnTypeInAsyncFunction";
+var errorCodes51 = [
   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: errorCodes50,
-  fixIds: [fixId39],
+  errorCodes: errorCodes51,
+  fixIds: [fixId40],
   getCodeActions: function getCodeActionsToFixReturnTypeInAsyncFunction(context) {
     const { sourceFile, program, span } = context;
     const checker = program.getTypeChecker();
@@ -160312,14 +161217,14 @@ registerCodeFix({
     const { returnTypeNode, returnType, promisedTypeNode, promisedType } = info;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(t, sourceFile, returnTypeNode, promisedTypeNode));
     return [createCodeFixAction(
-      fixId39,
+      fixId40,
       changes,
       [Diagnostics.Replace_0_with_Promise_1, checker.typeToString(returnType), checker.typeToString(promisedType)],
-      fixId39,
+      fixId40,
       Diagnostics.Fix_all_incorrect_return_type_of_an_async_functions
     )];
   },
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes50, (changes, diag2) => {
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes51, (changes, diag2) => {
     const info = getInfo16(diag2.file, context.program.getTypeChecker(), diag2.start);
     if (info) {
       doChange34(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode);
@@ -160355,13 +161260,13 @@ function doChange34(changes, sourceFile, returnTypeNode, promisedTypeNode) {
 
 // src/services/codefixes/disableJsDiagnostics.ts
 var fixName4 = "disableJsDiagnostics";
-var fixId40 = "disableJsDiagnostics";
-var errorCodes51 = mapDefined(Object.keys(Diagnostics), (key) => {
+var fixId41 = "disableJsDiagnostics";
+var errorCodes52 = mapDefined(Object.keys(Diagnostics), (key) => {
   const diag2 = Diagnostics[key];
   return diag2.category === 1 /* Error */ ? diag2.code : void 0;
 });
 registerCodeFix({
-  errorCodes: errorCodes51,
+  errorCodes: errorCodes52,
   getCodeActions: function getCodeActionsToDisableJsDiagnostics(context) {
     const { sourceFile, program, span, host, formatContext } = context;
     if (!isInJSFile(sourceFile) || !isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) {
@@ -160382,14 +161287,14 @@ registerCodeFix({
       )
     ];
     if (ts_textChanges_exports.isValidLocationToAddComment(sourceFile, span.start)) {
-      fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId40, 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, fixId41, Diagnostics.Add_ts_ignore_to_all_error_messages));
     }
     return fixes;
   },
-  fixIds: [fixId40],
+  fixIds: [fixId41],
   getAllCodeActions: (context) => {
     const seenLines = /* @__PURE__ */ new Set();
-    return codeFixAll(context, errorCodes51, (changes, diag2) => {
+    return codeFixAll(context, errorCodes52, (changes, diag2) => {
       if (ts_textChanges_exports.isValidLocationToAddComment(diag2.file, diag2.start)) {
         makeChange8(changes, diag2.file, diag2.start, seenLines);
       }
@@ -161388,9 +162293,9 @@ var fixName6 = "strictClassInitialization";
 var fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions";
 var fixIdAddUndefinedType = "addMissingPropertyUndefinedType";
 var fixIdAddInitializer = "addMissingPropertyInitializer";
-var errorCodes52 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
+var errorCodes53 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
 registerCodeFix({
-  errorCodes: errorCodes52,
+  errorCodes: errorCodes53,
   getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) {
     const info = getInfo17(context.sourceFile, context.span.start);
     if (!info)
@@ -161403,7 +162308,7 @@ registerCodeFix({
   },
   fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer],
   getAllCodeActions: (context) => {
-    return codeFixAll(context, errorCodes52, (changes, diag2) => {
+    return codeFixAll(context, errorCodes53, (changes, diag2) => {
       const info = getInfo17(diag2.file, diag2.start);
       if (!info)
         return;
@@ -161533,20 +162438,20 @@ function getDefaultValueFromType(checker, type) {
 }
 
 // src/services/codefixes/requireInTs.ts
-var fixId41 = "requireInTs";
-var errorCodes53 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
+var fixId42 = "requireInTs";
+var errorCodes54 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
 registerCodeFix({
-  errorCodes: errorCodes53,
+  errorCodes: errorCodes54,
   getCodeActions(context) {
     const info = getInfo18(context.sourceFile, context.program, context.span.start);
     if (!info) {
       return void 0;
     }
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(t, context.sourceFile, info));
-    return [createCodeFixAction(fixId41, changes, Diagnostics.Convert_require_to_import, fixId41, Diagnostics.Convert_all_require_to_import)];
+    return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_require_to_import, fixId42, Diagnostics.Convert_all_require_to_import)];
   },
-  fixIds: [fixId41],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes53, (changes, diag2) => {
+  fixIds: [fixId42],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes54, (changes, diag2) => {
     const info = getInfo18(diag2.file, context.program, diag2.start);
     if (info) {
       doChange35(changes, context.sourceFile, info);
@@ -161621,20 +162526,20 @@ function tryCreateNamedImportsFromObjectBindingPattern(node) {
 }
 
 // src/services/codefixes/useDefaultImport.ts
-var fixId42 = "useDefaultImport";
-var errorCodes54 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
+var fixId43 = "useDefaultImport";
+var errorCodes55 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
 registerCodeFix({
-  errorCodes: errorCodes54,
+  errorCodes: errorCodes55,
   getCodeActions(context) {
     const { sourceFile, span: { start } } = context;
     const info = getInfo19(sourceFile, start);
     if (!info)
       return void 0;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange36(t, sourceFile, info, context.preferences));
-    return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_to_default_import, fixId42, Diagnostics.Convert_all_to_default_imports)];
+    return [createCodeFixAction(fixId43, changes, Diagnostics.Convert_to_default_import, fixId43, Diagnostics.Convert_all_to_default_imports)];
   },
-  fixIds: [fixId42],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes54, (changes, diag2) => {
+  fixIds: [fixId43],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => {
     const info = getInfo19(diag2.file, diag2.start);
     if (info)
       doChange36(changes, diag2.file, info, context.preferences);
@@ -161663,21 +162568,21 @@ function doChange36(changes, sourceFile, info, preferences) {
 }
 
 // src/services/codefixes/useBigintLiteral.ts
-var fixId43 = "useBigintLiteral";
-var errorCodes55 = [
+var fixId44 = "useBigintLiteral";
+var errorCodes56 = [
   Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes55,
+  errorCodes: errorCodes56,
   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(fixId43, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId43, Diagnostics.Convert_all_to_bigint_numeric_literals)];
+      return [createCodeFixAction(fixId44, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId44, Diagnostics.Convert_all_to_bigint_numeric_literals)];
     }
   },
-  fixIds: [fixId43],
+  fixIds: [fixId44],
   getAllCodeActions: (context) => {
-    return codeFixAll(context, errorCodes55, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
+    return codeFixAll(context, errorCodes56, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
   }
 });
 function makeChange9(changeTracker, sourceFile, span) {
@@ -161691,18 +162596,18 @@ function makeChange9(changeTracker, sourceFile, span) {
 
 // src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts
 var fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof";
-var fixId44 = fixIdAddMissingTypeof;
-var errorCodes56 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
+var fixId45 = fixIdAddMissingTypeof;
+var errorCodes57 = [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: errorCodes56,
+  errorCodes: errorCodes57,
   getCodeActions: function getCodeActionsToAddMissingTypeof(context) {
     const { sourceFile, span } = context;
     const importType = getImportTypeNode(sourceFile, span.start);
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange37(t, sourceFile, importType));
-    return [createCodeFixAction(fixId44, changes, Diagnostics.Add_missing_typeof, fixId44, Diagnostics.Add_missing_typeof)];
+    return [createCodeFixAction(fixId45, changes, Diagnostics.Add_missing_typeof, fixId45, Diagnostics.Add_missing_typeof)];
   },
-  fixIds: [fixId44],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => doChange37(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
+  fixIds: [fixId45],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes57, (changes, diag2) => doChange37(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
 });
 function getImportTypeNode(sourceFile, pos) {
   const token = getTokenAtPosition(sourceFile, pos);
@@ -161725,9 +162630,9 @@ function doChange37(changes, sourceFile, importType) {
 
 // src/services/codefixes/wrapJsxInFragment.ts
 var fixID2 = "wrapJsxInFragment";
-var errorCodes57 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
+var errorCodes58 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
 registerCodeFix({
-  errorCodes: errorCodes57,
+  errorCodes: errorCodes58,
   getCodeActions: function getCodeActionsToWrapJsxInFragment(context) {
     const { sourceFile, span } = context;
     const node = findNodeToFix(sourceFile, span.start);
@@ -161737,7 +162642,7 @@ registerCodeFix({
     return [createCodeFixAction(fixID2, changes, Diagnostics.Wrap_in_JSX_fragment, fixID2, Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)];
   },
   fixIds: [fixID2],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes57, (changes, diag2) => {
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes58, (changes, diag2) => {
     const node = findNodeToFix(context.sourceFile, diag2.start);
     if (!node)
       return void 0;
@@ -161782,16 +162687,16 @@ function flattenInvalidBinaryExpr(node) {
 }
 
 // src/services/codefixes/wrapDecoratorInParentheses.ts
-var fixId45 = "wrapDecoratorInParentheses";
-var errorCodes58 = [Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator.code];
+var fixId46 = "wrapDecoratorInParentheses";
+var errorCodes59 = [Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator.code];
 registerCodeFix({
-  errorCodes: errorCodes58,
+  errorCodes: errorCodes59,
   getCodeActions: function getCodeActionsToWrapDecoratorExpressionInParentheses(context) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span.start));
-    return [createCodeFixAction(fixId45, changes, Diagnostics.Wrap_in_parentheses, fixId45, Diagnostics.Wrap_all_invalid_decorator_expressions_in_parentheses)];
+    return [createCodeFixAction(fixId46, changes, Diagnostics.Wrap_in_parentheses, fixId46, Diagnostics.Wrap_all_invalid_decorator_expressions_in_parentheses)];
   },
-  fixIds: [fixId45],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes58, (changes, diag2) => makeChange10(changes, diag2.file, diag2.start))
+  fixIds: [fixId46],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, diag2) => makeChange10(changes, diag2.file, diag2.start))
 });
 function makeChange10(changeTracker, sourceFile, pos) {
   const token = getTokenAtPosition(sourceFile, pos);
@@ -161802,10 +162707,10 @@ function makeChange10(changeTracker, sourceFile, pos) {
 }
 
 // src/services/codefixes/convertToMappedObjectType.ts
-var fixId46 = "fixConvertToMappedObjectType";
-var errorCodes59 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
+var fixId47 = "fixConvertToMappedObjectType";
+var errorCodes60 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
 registerCodeFix({
-  errorCodes: errorCodes59,
+  errorCodes: errorCodes60,
   getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) {
     const { sourceFile, span } = context;
     const info = getInfo20(sourceFile, span.start);
@@ -161813,10 +162718,10 @@ registerCodeFix({
       return void 0;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange39(t, sourceFile, info));
     const name = idText(info.container.name);
-    return [createCodeFixAction(fixId46, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId46, [Diagnostics.Convert_0_to_mapped_object_type, name])];
+    return [createCodeFixAction(fixId47, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId47, [Diagnostics.Convert_0_to_mapped_object_type, name])];
   },
-  fixIds: [fixId46],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes59, (changes, diag2) => {
+  fixIds: [fixId47],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes60, (changes, diag2) => {
     const info = getInfo20(diag2.file, diag2.start);
     if (info)
       doChange39(changes, diag2.file, info);
@@ -161864,12 +162769,12 @@ function doChange39(changes, sourceFile, { indexSignature, container }) {
 }
 
 // src/services/codefixes/removeAccidentalCallParentheses.ts
-var fixId47 = "removeAccidentalCallParentheses";
-var errorCodes60 = [
+var fixId48 = "removeAccidentalCallParentheses";
+var errorCodes61 = [
   Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes60,
+  errorCodes: errorCodes61,
   getCodeActions(context) {
     const callExpression = findAncestor(getTokenAtPosition(context.sourceFile, context.span.start), isCallExpression);
     if (!callExpression) {
@@ -161878,27 +162783,27 @@ registerCodeFix({
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
       t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end });
     });
-    return [createCodeFixActionWithoutFixAll(fixId47, changes, Diagnostics.Remove_parentheses)];
+    return [createCodeFixActionWithoutFixAll(fixId48, changes, Diagnostics.Remove_parentheses)];
   },
-  fixIds: [fixId47]
+  fixIds: [fixId48]
 });
 
 // src/services/codefixes/removeUnnecessaryAwait.ts
-var fixId48 = "removeUnnecessaryAwait";
-var errorCodes61 = [
+var fixId49 = "removeUnnecessaryAwait";
+var errorCodes62 = [
   Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code
 ];
 registerCodeFix({
-  errorCodes: errorCodes61,
+  errorCodes: errorCodes62,
   getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span));
     if (changes.length > 0) {
-      return [createCodeFixAction(fixId48, changes, Diagnostics.Remove_unnecessary_await, fixId48, Diagnostics.Remove_all_unnecessary_uses_of_await)];
+      return [createCodeFixAction(fixId49, changes, Diagnostics.Remove_unnecessary_await, fixId49, Diagnostics.Remove_all_unnecessary_uses_of_await)];
     }
   },
-  fixIds: [fixId48],
+  fixIds: [fixId49],
   getAllCodeActions: (context) => {
-    return codeFixAll(context, errorCodes61, (changes, diag2) => makeChange11(changes, diag2.file, diag2));
+    return codeFixAll(context, errorCodes62, (changes, diag2) => makeChange11(changes, diag2.file, diag2));
   }
 });
 function makeChange11(changeTracker, sourceFile, span) {
@@ -161926,20 +162831,20 @@ function makeChange11(changeTracker, sourceFile, span) {
 }
 
 // src/services/codefixes/splitTypeOnlyImport.ts
-var errorCodes62 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
-var fixId49 = "splitTypeOnlyImport";
+var errorCodes63 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
+var fixId50 = "splitTypeOnlyImport";
 registerCodeFix({
-  errorCodes: errorCodes62,
-  fixIds: [fixId49],
+  errorCodes: errorCodes63,
+  fixIds: [fixId50],
   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(fixId49, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId49, Diagnostics.Split_all_invalid_type_only_imports)];
+      return [createCodeFixAction(fixId50, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId50, Diagnostics.Split_all_invalid_type_only_imports)];
     }
   },
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes62, (changes, error2) => {
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes63, (changes, error2) => {
     splitTypeOnlyImport(changes, getImportDeclaration2(context.sourceFile, error2), context);
   })
 });
@@ -161988,23 +162893,23 @@ function splitTypeOnlyImport(changes, importDeclaration, context) {
 }
 
 // src/services/codefixes/convertConstToLet.ts
-var fixId50 = "fixConvertConstToLet";
-var errorCodes63 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
+var fixId51 = "fixConvertConstToLet";
+var errorCodes64 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
 registerCodeFix({
-  errorCodes: errorCodes63,
+  errorCodes: errorCodes64,
   getCodeActions: function getCodeActionsToConvertConstToLet(context) {
     const { sourceFile, span, program } = context;
     const info = getInfo21(sourceFile, span.start, program);
     if (info === void 0)
       return;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange40(t, sourceFile, info.token));
-    return [createCodeFixActionMaybeFixAll(fixId50, changes, Diagnostics.Convert_const_to_let, fixId50, Diagnostics.Convert_all_const_to_let)];
+    return [createCodeFixActionMaybeFixAll(fixId51, changes, Diagnostics.Convert_const_to_let, fixId51, 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, errorCodes63, (diag2) => {
+      eachDiagnostic(context, errorCodes64, (diag2) => {
         const info = getInfo21(diag2.file, diag2.start, program);
         if (info) {
           if (addToSeen(seen, getSymbolId(info.symbol))) {
@@ -162015,7 +162920,7 @@ registerCodeFix({
       });
     }));
   },
-  fixIds: [fixId50]
+  fixIds: [fixId51]
 });
 function getInfo21(sourceFile, pos, program) {
   var _a;
@@ -162036,11 +162941,11 @@ function doChange40(changes, sourceFile, token) {
 }
 
 // src/services/codefixes/fixExpectedComma.ts
-var fixId51 = "fixExpectedComma";
+var fixId52 = "fixExpectedComma";
 var expectedErrorCode = Diagnostics._0_expected.code;
-var errorCodes64 = [expectedErrorCode];
+var errorCodes65 = [expectedErrorCode];
 registerCodeFix({
-  errorCodes: errorCodes64,
+  errorCodes: errorCodes65,
   getCodeActions(context) {
     const { sourceFile } = context;
     const info = getInfo22(sourceFile, context.span.start, context.errorCode);
@@ -162048,15 +162953,15 @@ registerCodeFix({
       return void 0;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange41(t, sourceFile, info));
     return [createCodeFixAction(
-      fixId51,
+      fixId52,
       changes,
       [Diagnostics.Change_0_to_1, ";", ","],
-      fixId51,
+      fixId52,
       [Diagnostics.Change_0_to_1, ";", ","]
     )];
   },
-  fixIds: [fixId51],
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes64, (changes, diag2) => {
+  fixIds: [fixId52],
+  getAllCodeActions: (context) => codeFixAll(context, errorCodes65, (changes, diag2) => {
     const info = getInfo22(diag2.file, diag2.start, diag2.code);
     if (info)
       doChange41(changes, context.sourceFile, info);
@@ -162073,22 +162978,22 @@ function doChange41(changes, sourceFile, { node }) {
 
 // src/services/codefixes/fixAddVoidToPromise.ts
 var fixName7 = "addVoidToPromise";
-var fixId52 = "addVoidToPromise";
-var errorCodes65 = [
+var fixId53 = "addVoidToPromise";
+var errorCodes66 = [
   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: errorCodes65,
-  fixIds: [fixId52],
+  errorCodes: errorCodes66,
+  fixIds: [fixId53],
   getCodeActions(context) {
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange12(t, context.sourceFile, context.span, context.program));
     if (changes.length > 0) {
-      return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId52, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
+      return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId53, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
     }
   },
   getAllCodeActions(context) {
-    return codeFixAll(context, errorCodes65, (changes, diag2) => makeChange12(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
+    return codeFixAll(context, errorCodes66, (changes, diag2) => makeChange12(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
   }
 });
 function makeChange12(changes, sourceFile, span, program, seen) {
@@ -190862,10 +191767,10 @@ ${e.message}`;
     }
     return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions;
   }
-  getCombinedCodeFix({ scope, fixId: fixId53 }, simplifiedResult) {
+  getCombinedCodeFix({ scope, fixId: fixId54 }, simplifiedResult) {
     Debug.assert(scope.type === "file");
     const { file, project } = this.getFileAndProject(scope.args);
-    const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId53, this.getFormatOptions(file), this.getPreferences(file));
+    const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId54, this.getFormatOptions(file), this.getPreferences(file));
     if (simplifiedResult) {
       return { changes: this.mapTextChangesToCodeEdits(res.changes), commands: res.commands };
     } else {
@@ -190904,8 +191809,8 @@ ${e.message}`;
   mapCodeAction({ description: description3, changes, commands }) {
     return { description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands };
   }
-  mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId53, fixAllDescription }) {
-    return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId53, fixAllDescription };
+  mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId54, fixAllDescription }) {
+    return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId54, fixAllDescription };
   }
   mapTextChangesToCodeEdits(textChanges2) {
     return textChanges2.map((change) => this.mapTextChangeToCodeEdit(change));