@typescript-deploys/pr-build 5.2.0-pr-55052-3 → 5.2.0-pr-52095-16

package/lib/tsserver.js

@@ -970,6 +970,7 @@ __export(server_exports, {
   getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
+  getPropertyNameFromType: () => getPropertyNameFromType,
   getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
   getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
   getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
@@ -1802,6 +1803,7 @@ __export(server_exports, {
   isTypeQueryNode: () => isTypeQueryNode,
   isTypeReferenceNode: () => isTypeReferenceNode,
   isTypeReferenceType: () => isTypeReferenceType,
+  isTypeUsableAsPropertyName: () => isTypeUsableAsPropertyName,
   isUMDExportSymbol: () => isUMDExportSymbol,
   isUnaryExpression: () => isUnaryExpression,
   isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,
@@ -2327,7 +2329,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230718`;
+var version = `${versionMajorMinor}.0-insiders.20230725`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6810,7 +6812,8 @@ var SignatureFlags = /* @__PURE__ */ ((SignatureFlags5) => {
   SignatureFlags5[SignatureFlags5["IsOuterCallChain"] = 16] = "IsOuterCallChain";
   SignatureFlags5[SignatureFlags5["IsUntypedSignatureInJSFile"] = 32] = "IsUntypedSignatureInJSFile";
   SignatureFlags5[SignatureFlags5["IsNonInferrable"] = 64] = "IsNonInferrable";
-  SignatureFlags5[SignatureFlags5["PropagatingFlags"] = 39] = "PropagatingFlags";
+  SignatureFlags5[SignatureFlags5["IsSignatureCandidateForOverloadFailure"] = 128] = "IsSignatureCandidateForOverloadFailure";
+  SignatureFlags5[SignatureFlags5["PropagatingFlags"] = 167] = "PropagatingFlags";
   SignatureFlags5[SignatureFlags5["CallChainFlags"] = 24] = "CallChainFlags";
   return SignatureFlags5;
 })(SignatureFlags || {});
@@ -10189,9 +10192,6 @@ var Diagnostics = {
   await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(2852, 1 /* Error */, "await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_2852", "'await using' statements are only allowed within async functions and at the top levels of modules."),
   await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(2853, 1 /* Error */, "await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_th_2853", "'await using' statements are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."),
   Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(2854, 1 /* Error */, "Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_sys_2854", "Top-level 'await using' statements are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
-  The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method: diag(2855, 1 /* Error */, "The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_2855", "The left-hand side of an 'instanceof' expression must be assignable to the first argument of the right-hand side's '[Symbol.hasInstance]' method."),
-  An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_hand_side_of_an_instanceof_expression: diag(2856, 1 /* Error */, "An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_han_2856", "An object's '[Symbol.hasInstance]' method must return a boolean value for it to be used on the right-hand side of an 'instanceof' expression."),
-  The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_an_object_type_with_a_Symbol_hasInstance_method_or_a_type_assignable_to_the_Function_interface_type: diag(2857, 1 /* Error */, "The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_an_object_type_with_a_Sym_2857", "The right-hand side of an 'instanceof' expression must be either of type 'any', an object type with a '[Symbol.hasInstance]()' method, or a type assignable to the 'Function' interface type."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -14665,7 +14665,6 @@ function isLeftHandSideExpressionKind(kind) {
     case 236 /* MetaProperty */:
     case 102 /* ImportKeyword */:
     case 282 /* MissingDeclaration */:
-    case 237 /* SyntheticExpression */:
       return true;
     default:
       return false;
@@ -21604,6 +21603,18 @@ function getTextOfJsxNamespacedName(node) {
 function intrinsicTagNameToString(node) {
   return isIdentifier(node) ? idText(node) : getTextOfJsxNamespacedName(node);
 }
+function isTypeUsableAsPropertyName(type) {
+  return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
+}
+function getPropertyNameFromType(type) {
+  if (type.flags & 8192 /* UniqueESSymbol */) {
+    return type.escapedName;
+  }
+  if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
+    return escapeLeadingUnderscores("" + type.value);
+  }
+  return Debug.fail();
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -35112,10 +35123,14 @@ var Parser;
         case 124 /* ProtectedKeyword */:
         case 125 /* PublicKeyword */:
         case 148 /* ReadonlyKeyword */:
+          const previousToken = token();
           nextToken();
           if (scanner2.hasPrecedingLineBreak()) {
             return false;
           }
+          if (previousToken === 138 /* DeclareKeyword */ && token() === 156 /* TypeKeyword */) {
+            return true;
+          }
           continue;
         case 162 /* GlobalKeyword */:
           nextToken();
@@ -35480,14 +35495,14 @@ var Parser;
   function parseObjectBindingPattern() {
     const pos = getNodePos();
     parseExpected(19 /* OpenBraceToken */);
-    const elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement);
+    const elements = allowInAnd(() => parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement));
     parseExpected(20 /* CloseBraceToken */);
     return finishNode(factory2.createObjectBindingPattern(elements), pos);
   }
   function parseArrayBindingPattern() {
     const pos = getNodePos();
     parseExpected(23 /* OpenBracketToken */);
-    const elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement);
+    const elements = allowInAnd(() => parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement));
     parseExpected(24 /* CloseBracketToken */);
     return finishNode(factory2.createArrayBindingPattern(elements), pos);
   }
@@ -36005,6 +36020,9 @@ var Parser;
   }
   function parseTypeAliasDeclaration(pos, hasJSDoc, modifiers) {
     parseExpected(156 /* TypeKeyword */);
+    if (scanner2.hasPrecedingLineBreak()) {
+      parseErrorAtCurrentToken(Diagnostics.Line_break_not_permitted_here);
+    }
     const name = parseIdentifier();
     const typeParameters = parseTypeParameters();
     parseExpected(64 /* EqualsToken */);
@@ -37906,7 +37924,7 @@ function getNamedArgRegEx(name) {
   return result;
 }
 var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im;
-var singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im;
+var singleLinePragmaRegEx = /^\/\/\/?\s*@([^\s:]+)(.*)\s*$/im;
 function extractPragmas(pragmas, range, text) {
   const tripleSlash = range.kind === 2 /* SingleLineCommentTrivia */ && tripleSlashXMLCommentStartRegEx.exec(text);
   if (tripleSlash) {
@@ -43873,6 +43891,9 @@ function getModuleInstanceStateForAliasTarget(specifier, visited) {
           if (found === 1 /* Instantiated */) {
             return found;
           }
+          if (statement.kind === 271 /* ImportEqualsDeclaration */) {
+            found = 1 /* Instantiated */;
+          }
         }
       }
       if (found !== void 0) {
@@ -47821,7 +47842,7 @@ function createTypeChecker(host) {
       return node ? getTypeFromTypeNode(node) : errorType;
     },
     getParameterType: getTypeAtPosition,
-    getParameterIdentifierNameAtPosition,
+    getParameterIdentifierInfoAtPosition,
     getPromisedTypeOfPromise,
     getAwaitedType: (type) => getAwaitedType(type),
     getReturnTypeOfSignature,
@@ -48574,7 +48595,6 @@ function createTypeChecker(host) {
   var potentialReflectCollisions = [];
   var potentialUnusedRenamedBindingElementsInTypes = [];
   var awaitedTypeStack = [];
-  var hasGlobalSymbolHasInstanceProperty;
   var diagnostics = createDiagnosticCollection();
   var suggestionDiagnostics = createDiagnosticCollection();
   var typeofType = createTypeofType();
@@ -49263,7 +49283,7 @@ function createTypeChecker(host) {
         if (name === "const" && isConstAssertion(location)) {
           return void 0;
         }
-        if (isModuleDeclaration(location) && lastLocation && location.name === lastLocation) {
+        if (isModuleOrEnumDeclaration(location) && lastLocation && location.name === lastLocation) {
           lastLocation = location;
           location = location.parent;
         }
@@ -50879,7 +50899,7 @@ function createTypeChecker(host) {
     return isStringLiteralLike(moduleReferenceExpression) ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation) : void 0;
   }
   function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation = false) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     if (startsWith(moduleReference, "@types/")) {
       const diag2 = Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
       const withoutAtTypePrefix = removePrefix(moduleReference, "@types/");
@@ -50914,8 +50934,11 @@ function createTypeChecker(host) {
           );
         }
       } else if (resolvedModule.resolvedUsingTsExtension && !shouldAllowImportingTsExtension(compilerOptions, currentSourceFile.fileName)) {
-        const tsExtension = Debug.checkDefined(tryExtractTSExtension(moduleReference));
-        error2(errorNode, Diagnostics.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled, tsExtension);
+        const importOrExport = ((_h = findAncestor(location, isImportDeclaration)) == null ? void 0 : _h.importClause) || findAncestor(location, or(isImportEqualsDeclaration, isExportDeclaration));
+        if (!((importOrExport == null ? void 0 : importOrExport.isTypeOnly) || findAncestor(location, isImportTypeNode))) {
+          const tsExtension = Debug.checkDefined(tryExtractTSExtension(moduleReference));
+          error2(errorNode, Diagnostics.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled, tsExtension);
+        }
       }
       if (sourceFile.symbol) {
         if (resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
@@ -50932,7 +50955,7 @@ function createTypeChecker(host) {
         if (moduleResolutionKind === 3 /* Node16 */ || moduleResolutionKind === 99 /* NodeNext */) {
           const isSyncImport = currentSourceFile.impliedNodeFormat === 1 /* CommonJS */ && !findAncestor(location, isImportCall) || !!findAncestor(location, isImportEqualsDeclaration);
           const overrideClauseHost = findAncestor(location, (l) => isImportTypeNode(l) || isExportDeclaration(l) || isImportDeclaration(l));
-          const overrideClause = overrideClauseHost && isImportTypeNode(overrideClauseHost) ? (_h = overrideClauseHost.assertions) == null ? void 0 : _h.assertClause : overrideClauseHost == null ? void 0 : overrideClauseHost.assertClause;
+          const overrideClause = overrideClauseHost && isImportTypeNode(overrideClauseHost) ? (_i = overrideClauseHost.assertions) == null ? void 0 : _i.assertClause : overrideClauseHost == null ? void 0 : overrideClauseHost.assertClause;
           if (isSyncImport && sourceFile.impliedNodeFormat === 99 /* ESNext */ && !getResolutionModeOverrideForClause(overrideClause)) {
             if (findAncestor(location, isImportEqualsDeclaration)) {
               error2(errorNode, Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead, moduleReference);
@@ -51035,7 +51058,7 @@ function createTypeChecker(host) {
           error2(errorNode, Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
         } else if (mode === 99 /* ESNext */ && resolutionIsNode16OrNext && isExtensionlessRelativePathImport) {
           const absoluteRef = getNormalizedAbsolutePath(moduleReference, getDirectoryPath(currentSourceFile.path));
-          const suggestedExt = (_i = suggestedExtensions.find(([actualExt, _importExt]) => host.fileExists(absoluteRef + actualExt))) == null ? void 0 : _i[1];
+          const suggestedExt = (_j = suggestedExtensions.find(([actualExt, _importExt]) => host.fileExists(absoluteRef + actualExt))) == null ? void 0 : _j[1];
           if (suggestedExt) {
             error2(
               errorNode,
@@ -52471,11 +52494,13 @@ function createTypeChecker(host) {
         return !!type2.target && isMappedTypeHomomorphic(type2.target) && !isMappedTypeHomomorphic(type2);
       }
       function createMappedTypeNodeFromType(type2) {
+        var _a2;
         Debug.assert(!!(type2.flags & 524288 /* Object */));
         const readonlyToken = type2.declaration.readonlyToken ? factory.createToken(type2.declaration.readonlyToken.kind) : void 0;
         const questionToken = type2.declaration.questionToken ? factory.createToken(type2.declaration.questionToken.kind) : void 0;
         let appropriateConstraintTypeNode;
         let newTypeVariable;
+        const needsModifierPreservingWrapper = !isMappedTypeWithKeyofConstraintDeclaration(type2) && !(getModifiersTypeFromMappedType(type2).flags & 2 /* Unknown */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && !(getConstraintTypeFromMappedType(type2).flags & 262144 /* TypeParameter */ && ((_a2 = getConstraintOfTypeParameter(getConstraintTypeFromMappedType(type2))) == null ? void 0 : _a2.flags) & 4194304 /* Index */);
         if (isMappedTypeWithKeyofConstraintDeclaration(type2)) {
           if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
             const newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
@@ -52483,6 +52508,11 @@ function createTypeChecker(host) {
             newTypeVariable = factory.createTypeReferenceNode(name);
           }
           appropriateConstraintTypeNode = factory.createTypeOperatorNode(143 /* KeyOfKeyword */, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context));
+        } else if (needsModifierPreservingWrapper) {
+          const newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
+          const name = typeParameterToName(newParam, context);
+          newTypeVariable = factory.createTypeReferenceNode(name);
+          appropriateConstraintTypeNode = newTypeVariable;
         } else {
           appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type2), context);
         }
@@ -52513,6 +52543,18 @@ function createTypeChecker(host) {
             result,
             factory.createKeywordTypeNode(146 /* NeverKeyword */)
           );
+        } else if (needsModifierPreservingWrapper) {
+          return factory.createConditionalTypeNode(
+            typeToTypeNodeHelper(getConstraintTypeFromMappedType(type2), context),
+            factory.createInferTypeNode(factory.createTypeParameterDeclaration(
+              /*modifiers*/
+              void 0,
+              factory.cloneNode(newTypeVariable.typeName),
+              factory.createTypeOperatorNode(143 /* KeyOfKeyword */, typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context))
+            )),
+            result,
+            factory.createKeywordTypeNode(146 /* NeverKeyword */)
+          );
         }
         return result;
       }
@@ -56285,7 +56327,7 @@ function createTypeChecker(host) {
       false,
       definedInMethod && !definedInConstructor
     ));
-    if (symbol.valueDeclaration && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
+    if (symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
       reportImplicitAny(symbol.valueDeclaration, anyType);
       return anyType;
     }
@@ -57564,9 +57606,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function isTypeUsableAsPropertyName(type) {
-    return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
-  }
   function isLateBindableName(node) {
     if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
       return false;
@@ -57587,15 +57626,6 @@ function createTypeChecker(host) {
   function isNonBindableDynamicName(node) {
     return isDynamicName(node) && !isLateBindableName(node);
   }
-  function getPropertyNameFromType(type) {
-    if (type.flags & 8192 /* UniqueESSymbol */) {
-      return type.escapedName;
-    }
-    if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
-      return escapeLeadingUnderscores("" + type.value);
-    }
-    return Debug.fail();
-  }
   function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) {
     Debug.assert(!!(getCheckFlags(symbol) & 4096 /* Late */), "Expected a late-bound symbol.");
     symbol.flags |= symbolFlags;
@@ -57645,6 +57675,7 @@ function createTypeChecker(host) {
     return links.resolvedSymbol;
   }
   function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
+    var _a, _b, _c;
     const links = getSymbolLinks(symbol);
     if (!links[resolutionKind]) {
       const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
@@ -57663,7 +57694,7 @@ function createTypeChecker(host) {
           }
         }
       }
-      const assignments = symbol.assignmentDeclarationMembers;
+      const assignments = (((_a = symbol.valueDeclaration) == null ? void 0 : _a.kind) === 219 /* ArrowFunction */ || ((_b = symbol.valueDeclaration) == null ? void 0 : _b.kind) === 218 /* FunctionExpression */) && ((_c = getSymbolOfNode(symbol.valueDeclaration.parent)) == null ? void 0 : _c.assignmentDeclarationMembers) || symbol.assignmentDeclarationMembers;
       if (assignments) {
         const decls = arrayFrom(assignments.values());
         for (const member of decls) {
@@ -57792,7 +57823,7 @@ function createTypeChecker(host) {
       /*resolvedTypePredicate*/
       void 0,
       sig.minArgumentCount,
-      sig.flags & 39 /* PropagatingFlags */
+      sig.flags & 167 /* PropagatingFlags */
     );
     result.target = sig.target;
     result.mapper = sig.mapper;
@@ -58093,7 +58124,7 @@ function createTypeChecker(host) {
       /*resolvedTypePredicate*/
       void 0,
       minArgCount,
-      (left.flags | right.flags) & 39 /* PropagatingFlags */
+      (left.flags | right.flags) & 167 /* PropagatingFlags */
     );
     result.compositeKind = 1048576 /* Union */;
     result.compositeSignatures = concatenate(left.compositeKind !== 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]);
@@ -58241,20 +58272,17 @@ function createTypeChecker(host) {
       setStructuredTypeMembers(type, members2, callSignatures, constructSignatures, indexInfos2);
       return;
     }
-    let members = emptySymbols;
+    let members = getExportsOfSymbol(symbol);
     let indexInfos;
-    if (symbol.exports) {
-      members = getExportsOfSymbol(symbol);
-      if (symbol === globalThisSymbol) {
-        const varsOnly = /* @__PURE__ */ new Map();
-        members.forEach((p) => {
-          var _a;
-          if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a = p.declarations) == null ? void 0 : _a.length) && every(p.declarations, isAmbientModule))) {
-            varsOnly.set(p.escapedName, p);
-          }
-        });
-        members = varsOnly;
-      }
+    if (symbol === globalThisSymbol) {
+      const varsOnly = /* @__PURE__ */ new Map();
+      members.forEach((p) => {
+        var _a;
+        if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a = p.declarations) == null ? void 0 : _a.length) && every(p.declarations, isAmbientModule))) {
+          varsOnly.set(p.escapedName, p);
+        }
+      });
+      members = varsOnly;
     }
     let baseConstructorIndexInfo;
     setStructuredTypeMembers(type, members, emptyArray, emptyArray, emptyArray);
@@ -58303,7 +58331,7 @@ function createTypeChecker(host) {
             /*resolvedTypePredicate*/
             void 0,
             sig.minArgumentCount,
-            sig.flags & 39 /* PropagatingFlags */
+            sig.flags & 167 /* PropagatingFlags */
           ) : void 0
         ));
       }
@@ -63086,7 +63114,7 @@ function createTypeChecker(host) {
       /*resolvedTypePredicate*/
       void 0,
       signature.minArgumentCount,
-      signature.flags & 39 /* PropagatingFlags */
+      signature.flags & 167 /* PropagatingFlags */
     );
     result.target = signature;
     result.mapper = mapper;
@@ -70347,12 +70375,15 @@ function createTypeChecker(host) {
             return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
           }
           const target = getReferenceCandidate(expr.right);
-          const leftType = getTypeOfExpression(expr.left);
-          if (leftType.flags & 8576 /* StringOrNumberLiteralOrUnique */) {
-            if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target) && getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
+          if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target)) {
+            const leftType = getTypeOfExpression(expr.left);
+            if (isTypeUsableAsPropertyName(leftType) && getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
               return getTypeWithFacts(type, assumeTrue ? 524288 /* NEUndefined */ : 65536 /* EQUndefined */);
             }
-            if (isMatchingReference(reference, target)) {
+          }
+          if (isMatchingReference(reference, target)) {
+            const leftType = getTypeOfExpression(expr.left);
+            if (isTypeUsableAsPropertyName(leftType)) {
               return narrowTypeByInKeyword(type, leftType, assumeTrue);
             }
           }
@@ -70617,15 +70648,6 @@ function createTypeChecker(host) {
         return type;
       }
       const rightType = getTypeOfExpression(expr.right);
-      const hasInstanceMethodType = getSymbolHasInstanceMethodOfObjectType(rightType);
-      if (hasInstanceMethodType) {
-        const syntheticCall = createSyntheticHasInstanceMethodCall(left, expr.right, type, hasInstanceMethodType);
-        const signature = getEffectsSignature(syntheticCall);
-        const predicate = signature && getTypePredicateOfSignature(signature);
-        if (predicate && (predicate.kind === 0 /* This */ || predicate.kind === 1 /* Identifier */)) {
-          return narrowTypeByTypePredicate(type, predicate, syntheticCall, assumeTrue);
-        }
-      }
       if (!isTypeDerivedFrom(rightType, globalFunctionType)) {
         return type;
       }
@@ -70705,12 +70727,8 @@ function createTypeChecker(host) {
     }
     function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) {
       if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) {
-        let predicateArgument = getTypePredicateArgument(predicate, callExpression);
+        const predicateArgument = getTypePredicateArgument(predicate, callExpression);
         if (predicateArgument) {
-          if (isSyntheticExpression(predicateArgument) && predicate.parameterIndex === 0 && isSyntheticHasInstanceMethodCall(callExpression)) {
-            Debug.assertNode(predicateArgument.parent, isExpression);
-            predicateArgument = predicateArgument.parent;
-          }
           if (isMatchingReference(reference, predicateArgument)) {
             return getNarrowedType(
               type,
@@ -71963,41 +71981,75 @@ function createTypeChecker(host) {
     return mapType(
       type,
       (t) => {
-        var _a;
-        if (isGenericMappedType(t) && !t.declaration.nameType) {
-          const constraint = getConstraintTypeFromMappedType(t);
-          const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-          const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-          if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-            return substituteIndexedMappedType(t, propertyNameType);
-          }
-        } else if (t.flags & 3670016 /* StructuredType */) {
-          const prop = getPropertyOfType(t, name);
-          if (prop) {
-            return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
-          }
-          if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-            const restType = getElementTypeOfSliceOfTupleType(
-              t,
-              t.target.fixedLength,
-              /*endSkipCount*/
-              0,
-              /*writing*/
-              false,
-              /*noReductions*/
-              true
-            );
-            if (restType) {
-              return restType;
+        if (!(t.flags & 3670016 /* StructuredType */)) {
+          return void 0;
+        }
+        if (t.flags & 2097152 /* Intersection */) {
+          const intersection = t;
+          let applicableIndexedMappedTypeSubstitions;
+          let concretePropertyTypes;
+          let applicableIndexInfoCandidates;
+          for (const t2 of intersection.types) {
+            if (isGenericMappedType(t2) && !t2.declaration.nameType) {
+              applicableIndexedMappedTypeSubstitions = append(applicableIndexedMappedTypeSubstitions, getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t2));
+              continue;
+            }
+            const typeOfConcreteProperty = getTypeOfConcretePropertyOfContextualType(t2);
+            if (typeOfConcreteProperty) {
+              concretePropertyTypes = append(concretePropertyTypes, typeOfConcreteProperty);
+              continue;
             }
+            applicableIndexInfoCandidates = append(applicableIndexInfoCandidates, t2);
+          }
+          if (concretePropertyTypes) {
+            return getIntersectionType(concatenate(concretePropertyTypes, applicableIndexedMappedTypeSubstitions));
+          }
+          const types = concatenate(mapDefined(applicableIndexInfoCandidates, getTypeOfApplicableIndexInfoOfContextualType), applicableIndexedMappedTypeSubstitions);
+          if (types.length > 0) {
+            return getIntersectionType(types);
           }
-          return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+          return void 0;
         }
-        return void 0;
+        return isGenericMappedType(t) && !t.declaration.nameType ? getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) : getTypeOfConcretePropertyOfContextualType(t) || getTypeOfApplicableIndexInfoOfContextualType(t);
       },
       /*noReductions*/
       true
     );
+    function getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) {
+      const constraint = getConstraintTypeFromMappedType(t);
+      const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+      const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+      if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+        return substituteIndexedMappedType(t, propertyNameType);
+      }
+      return void 0;
+    }
+    function getTypeOfConcretePropertyOfContextualType(t) {
+      const prop = getPropertyOfType(t, name);
+      if (prop) {
+        return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
+      }
+      if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
+        const restType = getElementTypeOfSliceOfTupleType(
+          t,
+          t.target.fixedLength,
+          /*endSkipCount*/
+          0,
+          /*writing*/
+          false,
+          /*noReductions*/
+          true
+        );
+        if (restType) {
+          return restType;
+        }
+      }
+      return void 0;
+    }
+    function getTypeOfApplicableIndexInfoOfContextualType(t) {
+      var _a;
+      return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+    }
   }
   function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
     Debug.assert(isObjectLiteralMethod(node));
@@ -72548,7 +72600,7 @@ function createTypeChecker(host) {
       /*resolvedTypePredicate*/
       void 0,
       minArgCount,
-      (left.flags | right.flags) & 39 /* PropagatingFlags */
+      (left.flags | right.flags) & 167 /* PropagatingFlags */
     );
     result.compositeKind = 2097152 /* Intersection */;
     result.compositeSignatures = concatenate(left.compositeKind === 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]);
@@ -75287,7 +75339,7 @@ function createTypeChecker(host) {
     }
     return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
   }
-  function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, headMessageCallback) {
+  function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, headMessage) {
     const isTaggedTemplate = node.kind === 215 /* TaggedTemplateExpression */;
     const isDecorator2 = node.kind === 170 /* Decorator */;
     const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node);
@@ -75330,7 +75382,6 @@ function createTypeChecker(host) {
             chain = chainDiagnosticMessages(chain, Diagnostics.The_last_overload_gave_the_following_error);
             chain = chainDiagnosticMessages(chain, Diagnostics.No_overload_matches_this_call);
           }
-          const headMessage = headMessageCallback == null ? void 0 : headMessageCallback();
           if (headMessage) {
             chain = chainDiagnosticMessages(chain, headMessage);
           }
@@ -75398,7 +75449,6 @@ function createTypeChecker(host) {
             map(diags, createDiagnosticMessageChainFromDiagnostic),
             Diagnostics.No_overload_matches_this_call
           );
-          const headMessage = headMessageCallback == null ? void 0 : headMessageCallback();
           if (headMessage) {
             chain = chainDiagnosticMessages(chain, headMessage);
           }
@@ -75414,21 +75464,21 @@ function createTypeChecker(host) {
           diagnostics.add(diag2);
         }
       } else if (candidateForArgumentArityError) {
-        diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args, headMessageCallback == null ? void 0 : headMessageCallback()));
+        diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args, headMessage));
       } else if (candidateForTypeArgumentError) {
         checkTypeArguments(
           candidateForTypeArgumentError,
           node.typeArguments,
           /*reportErrors*/
           true,
-          headMessageCallback == null ? void 0 : headMessageCallback()
+          headMessage
         );
       } else {
         const signaturesWithCorrectTypeArgumentArity = filter(signatures, (s) => hasCorrectTypeArgumentArity(s, typeArguments));
         if (signaturesWithCorrectTypeArgumentArity.length === 0) {
-          diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments, headMessageCallback == null ? void 0 : headMessageCallback()));
+          diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments, headMessage));
         } else {
-          diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args, headMessageCallback == null ? void 0 : headMessageCallback()));
+          diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args, headMessage));
         }
       }
     }
@@ -75579,7 +75629,7 @@ function createTypeChecker(host) {
       parameters.push(createCombinedSymbolFromTypes(symbols, mapDefined(candidates, (candidate) => tryGetTypeAtPosition(candidate, i))));
     }
     const restParameterSymbols = mapDefined(candidates, (c) => signatureHasRestParameter(c) ? last(c.parameters) : void 0);
-    let flags = 0 /* None */;
+    let flags = 128 /* IsSignatureCandidateForOverloadFailure */;
     if (restParameterSymbols.length !== 0) {
       const type = createArrayType(getUnionType(mapDefined(candidates, tryGetRestTypeOfSignature), 2 /* Subtype */));
       parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type));
@@ -75736,7 +75786,7 @@ function createTypeChecker(host) {
       error2(node, Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
       return resolveErrorCall(node);
     }
-    return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags, () => isSyntheticHasInstanceMethodCall(node) ? Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method : void 0);
+    return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
   }
   function isGenericFunctionReturningFunction(signature) {
     return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
@@ -76033,7 +76083,7 @@ function createTypeChecker(host) {
       invocationErrorRecovery(apparentType, 0 /* Call */, diag2);
       return resolveErrorCall(node);
     }
-    return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */, () => headMessage);
+    return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */, headMessage);
   }
   function createSignatureForJSXIntrinsic(node, result) {
     const namespace = getJsxNamespaceAt(node);
@@ -76303,6 +76353,8 @@ function createTypeChecker(host) {
     return returnType;
   }
   function checkDeprecatedSignature(signature, node) {
+    if (signature.flags & 128 /* IsSignatureCandidateForOverloadFailure */)
+      return;
     if (signature.declaration && signature.declaration.flags & 536870912 /* Deprecated */) {
       const suggestionNode = getDeprecatedSuggestionNode(node);
       const name = tryGetPropertyAccessOrIdentifierToString(getInvokedExpression(node));
@@ -76776,7 +76828,7 @@ function createTypeChecker(host) {
     }
     return restParameter.escapedName;
   }
-  function getParameterIdentifierNameAtPosition(signature, pos) {
+  function getParameterIdentifierInfoAtPosition(signature, pos) {
     var _a;
     if (((_a = signature.declaration) == null ? void 0 : _a.kind) === 324 /* JSDocFunctionType */) {
       return void 0;
@@ -76784,10 +76836,16 @@ function createTypeChecker(host) {
     const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
     if (pos < paramCount) {
       const param = signature.parameters[pos];
-      return isParameterDeclarationWithIdentifierName(param) ? [param.escapedName, false] : void 0;
+      const paramIdent = getParameterDeclarationIdentifier(param);
+      return paramIdent ? {
+        parameter: paramIdent,
+        parameterName: param.escapedName,
+        isRestParameter: false
+      } : void 0;
     }
     const restParameter = signature.parameters[paramCount] || unknownSymbol;
-    if (!isParameterDeclarationWithIdentifierName(restParameter)) {
+    const restIdent = getParameterDeclarationIdentifier(restParameter);
+    if (!restIdent) {
       return void 0;
     }
     const restType = getTypeOfSymbol(restParameter);
@@ -76796,18 +76854,19 @@ function createTypeChecker(host) {
       const index = pos - paramCount;
       const associatedName = associatedNames == null ? void 0 : associatedNames[index];
       const isRestTupleElement = !!(associatedName == null ? void 0 : associatedName.dotDotDotToken);
-      return associatedName ? [
-        getTupleElementLabel(associatedName),
-        isRestTupleElement
-      ] : void 0;
+      if (associatedName) {
+        Debug.assert(isIdentifier(associatedName.name));
+        return { parameter: associatedName.name, parameterName: associatedName.name.escapedText, isRestParameter: isRestTupleElement };
+      }
+      return void 0;
     }
     if (pos === paramCount) {
-      return [restParameter.escapedName, true];
+      return { parameter: restIdent, parameterName: restParameter.escapedName, isRestParameter: true };
     }
     return void 0;
   }
-  function isParameterDeclarationWithIdentifierName(symbol) {
-    return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name);
+  function getParameterDeclarationIdentifier(symbol) {
+    return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name) && symbol.valueDeclaration.name;
   }
   function isValidDeclarationForTupleLabel(d) {
     return d.kind === 202 /* NamedTupleMember */ || isParameter(d) && d.name && isIdentifier(d.name);
@@ -78066,32 +78125,6 @@ function createTypeChecker(host) {
   function isConstEnumSymbol(symbol) {
     return (symbol.flags & 128 /* ConstEnum */) !== 0;
   }
-  function getSymbolHasInstanceMethodOfObjectType(type) {
-    const hasInstancePropertyName = getPropertyNameForKnownSymbolName("hasInstance");
-    const hasInstanceProperty = getPropertyOfObjectType(type, hasInstancePropertyName);
-    if (hasInstanceProperty) {
-      const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
-      if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
-        return hasInstancePropertyType;
-      }
-    }
-  }
-  function createSyntheticHasInstanceMethodCall(left, right, leftType, hasInstanceMethodType) {
-    const syntheticExpression = createSyntheticExpression(right, hasInstanceMethodType);
-    const syntheticArgument = createSyntheticExpression(left, leftType);
-    const syntheticCall = parseNodeFactory.createCallExpression(
-      syntheticExpression,
-      /*typeArguments*/
-      void 0,
-      [syntheticArgument]
-    );
-    setParent(syntheticCall, left.parent);
-    setTextRange(syntheticCall, left.parent);
-    return syntheticCall;
-  }
-  function isSyntheticHasInstanceMethodCall(node) {
-    return isSyntheticExpression(node.expression) && node.arguments.length === 1 && isSyntheticExpression(node.arguments[0]) && isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 104 /* InstanceOfKeyword */ && node.parent.right === node.expression.parent && node.parent.left === node.arguments[0].parent;
-  }
   function checkInstanceOfExpression(left, right, leftType, rightType) {
     if (leftType === silentNeverType || rightType === silentNeverType) {
       return silentNeverType;
@@ -78099,31 +78132,8 @@ function createTypeChecker(host) {
     if (!isTypeAny(leftType) && allTypesAssignableToKind(leftType, 402784252 /* Primitive */)) {
       error2(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
     }
-    if (!isTypeAny(rightType)) {
-      const hasInstanceMethodType = getSymbolHasInstanceMethodOfObjectType(rightType);
-      if (hasInstanceMethodType) {
-        const cache = hasInstanceMethodType;
-        if (cache.hasSimpleUnrestrictedSingleCallSignature === void 0) {
-          const signature = getSingleCallSignature(hasInstanceMethodType);
-          cache.hasSimpleUnrestrictedSingleCallSignature = !!signature && signature.parameters.length === 1 && !!(getTypeOfSymbol(signature.parameters[0]).flags & 3 /* AnyOrUnknown */) && !!signature.resolvedReturnType && !!(signature.resolvedReturnType.flags & 16 /* Boolean */);
-        }
-        if (!cache.hasSimpleUnrestrictedSingleCallSignature) {
-          const syntheticCall = createSyntheticHasInstanceMethodCall(left, right, leftType, hasInstanceMethodType);
-          const returnType = getReturnTypeOfSignature(getResolvedSignature(syntheticCall));
-          checkTypeAssignableTo(returnType, booleanType, right, Diagnostics.An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_hand_side_of_an_instanceof_expression);
-        }
-      }
-      if (!(hasInstanceMethodType || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
-        if (hasGlobalSymbolHasInstanceProperty === void 0) {
-          const globalESSymbolConstructorSymbol = getGlobalESSymbolConstructorTypeSymbol(
-            /*reportErrors*/
-            false
-          );
-          hasGlobalSymbolHasInstanceProperty = !!globalESSymbolConstructorSymbol && getMembersOfSymbol(globalESSymbolConstructorSymbol).has("hasInstance");
-        }
-        const message = hasGlobalSymbolHasInstanceProperty ? Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_an_object_type_with_a_Symbol_hasInstance_method_or_a_type_assignable_to_the_Function_interface_type : Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type;
-        error2(right, message);
-      }
+    if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
+      error2(right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
     }
     return booleanType;
   }
@@ -127102,7 +127112,6 @@ function createWatchProgram(host) {
     if (hasChangedCompilerOptions) {
       newLine = updateNewLine();
       if (program && changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
-        debugger;
         resolutionCache.onChangesAffectModuleResolution();
       }
     }
@@ -136096,8 +136105,8 @@ function computeSuggestionDiagnostics(sourceFile, program, cancellationToken) {
           diags.push(createDiagnosticForNode(init, Diagnostics.require_call_may_be_converted_to_an_import));
         }
       }
-      const jsdocTypedefNode = ts_codefix_exports.getJSDocTypedefNode(node);
-      if (jsdocTypedefNode) {
+      const jsdocTypedefNodes = ts_codefix_exports.getJSDocTypedefNodes(node);
+      for (const jsdocTypedefNode of jsdocTypedefNodes) {
         diags.push(createDiagnosticForNode(jsdocTypedefNode, Diagnostics.JSDoc_typedef_may_be_converted_to_TypeScript_type));
       }
       if (ts_codefix_exports.parameterShouldGetTypeFromJSDoc(node)) {
@@ -146916,7 +146925,7 @@ __export(ts_codefix_exports, {
   getFixes: () => getFixes,
   getImportCompletionAction: () => getImportCompletionAction,
   getImportKind: () => getImportKind,
-  getJSDocTypedefNode: () => getJSDocTypedefNode,
+  getJSDocTypedefNodes: () => getJSDocTypedefNodes,
   getNoopSymbolTrackerWithResolver: () => getNoopSymbolTrackerWithResolver,
   getPromoteTypeOnlyCompletionAction: () => getPromoteTypeOnlyCompletionAction,
   getSupportedErrorCodes: () => getSupportedErrorCodes,
@@ -149638,13 +149647,14 @@ registerCodeFix({
   fixIds: [fixId14],
   errorCodes: errorCodes15,
   getCodeActions(context) {
+    const newLineCharacter = getNewLineOrDefaultFromHost(context.host, context.formatContext.options);
     const node = getTokenAtPosition(
       context.sourceFile,
       context.span.start
     );
     if (!node)
       return;
-    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange12(t, node, context.sourceFile));
+    const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange12(t, node, context.sourceFile, newLineCharacter));
     if (changes.length > 0) {
       return [
         createCodeFixAction(
@@ -149657,29 +149667,72 @@ registerCodeFix({
       ];
     }
   },
-  getAllCodeActions: (context) => codeFixAll(context, errorCodes15, (changes, diag2) => {
-    const node = getTokenAtPosition(diag2.file, diag2.start);
-    if (node)
-      doChange12(changes, node, diag2.file);
-  })
+  getAllCodeActions: (context) => codeFixAll(
+    context,
+    errorCodes15,
+    (changes, diag2) => {
+      const newLineCharacter = getNewLineOrDefaultFromHost(context.host, context.formatContext.options);
+      const node = getTokenAtPosition(diag2.file, diag2.start);
+      const fixAll = true;
+      if (node)
+        doChange12(changes, node, diag2.file, newLineCharacter, fixAll);
+    }
+  )
 });
-function doChange12(changes, node, sourceFile) {
-  if (isJSDocTypedefTag(node)) {
-    fixSingleTypeDef(changes, node, sourceFile);
-  }
-}
-function fixSingleTypeDef(changes, typeDefNode, sourceFile) {
-  if (!typeDefNode)
+function doChange12(changes, node, sourceFile, newLine, fixAll = false) {
+  if (!isJSDocTypedefTag(node))
     return;
-  const declaration = createDeclaration(typeDefNode);
+  const declaration = createDeclaration(node);
   if (!declaration)
     return;
-  const comment = typeDefNode.parent;
-  changes.replaceNode(
-    sourceFile,
-    comment,
-    declaration
+  const commentNode = node.parent;
+  const { leftSibling, rightSibling } = getLeftAndRightSiblings(node);
+  let pos = commentNode.getStart();
+  let prefix = "";
+  if (!leftSibling && commentNode.comment) {
+    pos = findEndOfTextBetween(commentNode, commentNode.getStart(), node.getStart());
+    prefix = `${newLine} */${newLine}`;
+  }
+  if (leftSibling) {
+    if (fixAll && isJSDocTypedefTag(leftSibling)) {
+      pos = node.getStart();
+      prefix = "";
+    } else {
+      pos = findEndOfTextBetween(commentNode, leftSibling.getStart(), node.getStart());
+      prefix = `${newLine} */${newLine}`;
+    }
+  }
+  let end = commentNode.getEnd();
+  let suffix = "";
+  if (rightSibling) {
+    if (fixAll && isJSDocTypedefTag(rightSibling)) {
+      end = rightSibling.getStart();
+      suffix = `${newLine}${newLine}`;
+    } else {
+      end = rightSibling.getStart();
+      suffix = `${newLine}/**${newLine} * `;
+    }
+  }
+  changes.replaceRange(sourceFile, { pos, end }, declaration, { prefix, suffix });
+}
+function getLeftAndRightSiblings(typedefNode) {
+  const commentNode = typedefNode.parent;
+  const maxChildIndex = commentNode.getChildCount() - 1;
+  const currentNodeIndex = commentNode.getChildren().findIndex(
+    (n) => n.getStart() === typedefNode.getStart() && n.getEnd() === typedefNode.getEnd()
   );
+  const leftSibling = currentNodeIndex > 0 ? commentNode.getChildAt(currentNodeIndex - 1) : void 0;
+  const rightSibling = currentNodeIndex < maxChildIndex ? commentNode.getChildAt(currentNodeIndex + 1) : void 0;
+  return { leftSibling, rightSibling };
+}
+function findEndOfTextBetween(jsDocComment, from, to) {
+  const comment = jsDocComment.getText().substring(from - jsDocComment.getStart(), to - jsDocComment.getStart());
+  for (let i = comment.length; i > 0; i--) {
+    if (!/[*\/\s]/g.test(comment.substring(i - 1, i))) {
+      return from + i;
+    }
+  }
+  return to;
 }
 function createDeclaration(tag) {
   var _a;
@@ -149700,7 +149753,7 @@ function createInterfaceForTypeLiteral(typeName, typeLiteral) {
   const propertySignatures = createSignatureFromTypeLiteral(typeLiteral);
   if (!some(propertySignatures))
     return;
-  const interfaceDeclaration = factory.createInterfaceDeclaration(
+  return factory.createInterfaceDeclaration(
     /*modifiers*/
     void 0,
     typeName,
@@ -149710,13 +149763,12 @@ function createInterfaceForTypeLiteral(typeName, typeLiteral) {
     void 0,
     propertySignatures
   );
-  return interfaceDeclaration;
 }
 function createTypeAliasForTypeExpression(typeName, typeExpression) {
   const typeReference = getSynthesizedDeepClone(typeExpression.type);
   if (!typeReference)
     return;
-  const declaration = factory.createTypeAliasDeclaration(
+  return factory.createTypeAliasDeclaration(
     /*modifiers*/
     void 0,
     factory.createIdentifier(typeName),
@@ -149724,7 +149776,6 @@ function createTypeAliasForTypeExpression(typeName, typeExpression) {
     void 0,
     typeReference
   );
-  return declaration;
 }
 function createSignatureFromTypeLiteral(typeLiteral) {
   const propertyTags = typeLiteral.jsDocPropertyTags;
@@ -149744,30 +149795,28 @@ function createSignatureFromTypeLiteral(typeLiteral) {
     }
     if (typeReference && name) {
       const questionToken = isOptional ? factory.createToken(58 /* QuestionToken */) : void 0;
-      const prop = factory.createPropertySignature(
+      return factory.createPropertySignature(
         /*modifiers*/
         void 0,
         name,
         questionToken,
         typeReference
       );
-      return prop;
     }
   };
-  const props = mapDefined(propertyTags, getSignature);
-  return props;
+  return mapDefined(propertyTags, getSignature);
 }
 function getPropertyName(tag) {
   return tag.name.kind === 80 /* Identifier */ ? tag.name.text : tag.name.right.text;
 }
-function getJSDocTypedefNode(node) {
+function getJSDocTypedefNodes(node) {
   if (hasJSDocNodes(node)) {
-    return forEach(node.jsDoc, (node2) => {
+    return flatMap(node.jsDoc, (doc) => {
       var _a;
-      return (_a = node2.tags) == null ? void 0 : _a.find(isJSDocTypedefTag);
+      return (_a = doc.tags) == null ? void 0 : _a.filter((tag) => isJSDocTypedefTag(tag));
     });
   }
-  return void 0;
+  return [];
 }
 
 // src/services/codefixes/convertLiteralTypeToMappedType.ts
@@ -150900,6 +150949,14 @@ function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceF
   }
   function promoteImportClause(importClause) {
     changes.delete(sourceFile, getTypeKeywordOfTypeOnlyImport(importClause, sourceFile));
+    if (!compilerOptions.allowImportingTsExtensions) {
+      const moduleSpecifier = tryGetModuleSpecifierFromDeclaration(importClause.parent);
+      const resolvedModule = moduleSpecifier && getResolvedModule(sourceFile, moduleSpecifier.text, getModeForUsageLocation(sourceFile, moduleSpecifier));
+      if (resolvedModule == null ? void 0 : resolvedModule.resolvedUsingTsExtension) {
+        const changedExtension = changeAnyExtension(moduleSpecifier.text, getOutputExtension(moduleSpecifier.text, compilerOptions));
+        changes.replaceNode(sourceFile, moduleSpecifier, factory.createStringLiteral(changedExtension));
+      }
+    }
     if (convertExistingToTypeOnly) {
       const namedImports = tryCast(importClause.namedBindings, isNamedImports);
       if (namedImports && namedImports.elements.length > 1) {
@@ -152017,6 +152074,8 @@ function getInfo9(checker, sourceFile, position, errorCode) {
       if (!declaration || !isCallExpression(declaration.parent) || !declaration.body)
         return void 0;
       const pos = declaration.parent.arguments.indexOf(declaration);
+      if (pos === -1)
+        return void 0;
       const type = checker.getContextualTypeForArgumentAtIndex(declaration.parent, pos);
       if (!type)
         return void 0;
@@ -155184,15 +155243,11 @@ var PreserveOptionalFlags = /* @__PURE__ */ ((PreserveOptionalFlags2) => {
 })(PreserveOptionalFlags || {});
 function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional = 3 /* All */, isAmbient = false) {
   const declarations = symbol.getDeclarations();
-  const declaration = declarations == null ? void 0 : declarations[0];
+  const declaration = firstOrUndefined(declarations);
   const checker = context.program.getTypeChecker();
   const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
   const kind = (declaration == null ? void 0 : declaration.kind) ?? 171 /* PropertySignature */;
-  const declarationName = getSynthesizedDeepClone(
-    getNameOfDeclaration(declaration),
-    /*includeTrivia*/
-    false
-  );
+  const declarationName = createDeclarationName(symbol, declaration);
   const effectiveModifierFlags = declaration ? getEffectiveModifierFlags(declaration) : 0 /* None */;
   let modifierFlags = effectiveModifierFlags & 32 /* Static */;
   modifierFlags |= effectiveModifierFlags & 4 /* Public */ ? 4 /* Public */ : effectiveModifierFlags & 16 /* Protected */ ? 16 /* Protected */ : 0 /* None */;
@@ -155343,6 +155398,19 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
       false
     );
   }
+  function createDeclarationName(symbol2, declaration2) {
+    if (getCheckFlags(symbol2) & 262144 /* Mapped */) {
+      const nameType = symbol2.links.nameType;
+      if (nameType && isTypeUsableAsPropertyName(nameType)) {
+        return factory.createIdentifier(unescapeLeadingUnderscores(getPropertyNameFromType(nameType)));
+      }
+    }
+    return getSynthesizedDeepClone(
+      getNameOfDeclaration(declaration2),
+      /*includeTrivia*/
+      false
+    );
+  }
 }
 function createSignatureDeclarationFromSignature(kind, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder) {
   const program = context.program;
@@ -159202,7 +159270,8 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       const leftMostName = getLeftMostName(computedPropertyName.expression);
       const nameSymbol = leftMostName && typeChecker.getSymbolAtLocation(leftMostName);
       const firstAccessibleSymbol = nameSymbol && getFirstSymbolInChain(nameSymbol, contextToken, typeChecker);
-      if (firstAccessibleSymbol && addToSeen(seenPropertySymbols, getSymbolId(firstAccessibleSymbol))) {
+      const firstAccessibleSymbolId = firstAccessibleSymbol && getSymbolId(firstAccessibleSymbol);
+      if (firstAccessibleSymbolId && addToSeen(seenPropertySymbols, firstAccessibleSymbolId)) {
         const index = symbols.length;
         symbols.push(firstAccessibleSymbol);
         const moduleSymbol = firstAccessibleSymbol.parent;
@@ -159232,6 +159301,9 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
           }
         }
       } else if (preferences.includeCompletionsWithInsertText) {
+        if (firstAccessibleSymbolId && seenPropertySymbols.has(firstAccessibleSymbolId)) {
+          return;
+        }
         addSymbolOriginInfo(symbol);
         addSymbolSortInfo(symbol);
         symbols.push(symbol);
@@ -164556,7 +164628,7 @@ __export(ts_InlayHints_exports, {
 });
 
 // src/services/inlayHints.ts
-var maxHintsLength = 30;
+var maxTypeHintLength = 30;
 var leadingParameterNameCommentRegexFactory = (name) => {
   return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
 };
@@ -164566,6 +164638,9 @@ function shouldShowParameterNameHints(preferences) {
 function shouldShowLiteralParameterNameHintsOnly(preferences) {
   return preferences.includeInlayParameterNameHints === "literals";
 }
+function shouldUseInteractiveInlayHints(preferences) {
+  return preferences.interactiveInlayHints === true;
+}
 function provideInlayHints(context) {
   const { file, program, span, cancellationToken, preferences } = context;
   const sourceFileText = file.text;
@@ -164616,9 +164691,15 @@ function provideInlayHints(context) {
   function isSignatureSupportingReturnAnnotation(node) {
     return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
   }
-  function addParameterHints(text, position, isFirstVariadicArgument) {
+  function addParameterHints(text, parameter, position, isFirstVariadicArgument, sourceFile) {
+    let hintText = `${isFirstVariadicArgument ? "..." : ""}${text}`;
+    if (shouldUseInteractiveInlayHints(preferences)) {
+      hintText = [getNodeDisplayPart(hintText, parameter, sourceFile), { text: ":" }];
+    } else {
+      hintText += ":";
+    }
     result.push({
-      text: `${isFirstVariadicArgument ? "..." : ""}${truncation(text, maxHintsLength)}:`,
+      text: hintText,
       position,
       kind: "Parameter" /* Parameter */,
       whitespaceAfter: true
@@ -164626,7 +164707,7 @@ function provideInlayHints(context) {
   }
   function addTypeHints(text, position) {
     result.push({
-      text: `: ${truncation(text, maxHintsLength)}`,
+      text: `: ${text.length > maxTypeHintLength ? text.substr(0, maxTypeHintLength - "...".length) + "..." : text}`,
       position,
       kind: "Type" /* Type */,
       whitespaceBefore: true
@@ -164634,7 +164715,7 @@ function provideInlayHints(context) {
   }
   function addEnumMemberValueHints(text, position) {
     result.push({
-      text: `= ${truncation(text, maxHintsLength)}`,
+      text: `= ${text}`,
       position,
       kind: "Enum" /* Enum */,
       whitespaceBefore: true
@@ -164684,6 +164765,7 @@ function provideInlayHints(context) {
       return;
     }
     let signatureParamPos = 0;
+    const sourceFile = shouldUseInteractiveInlayHints(preferences) ? expr.getSourceFile() : void 0;
     for (const originalArg of args) {
       const arg = skipParentheses(originalArg);
       if (shouldShowLiteralParameterNameHintsOnly(preferences) && !isHintableLiteral(arg)) {
@@ -164704,10 +164786,10 @@ function provideInlayHints(context) {
           }
         }
       }
-      const identifierNameInfo = checker.getParameterIdentifierNameAtPosition(signature, signatureParamPos);
+      const identifierInfo = checker.getParameterIdentifierInfoAtPosition(signature, signatureParamPos);
       signatureParamPos = signatureParamPos + (spreadArgs || 1);
-      if (identifierNameInfo) {
-        const [parameterName, isFirstVariadicArgument] = identifierNameInfo;
+      if (identifierInfo) {
+        const { parameter, parameterName, isRestParameter: isFirstVariadicArgument } = identifierInfo;
         const isParameterNameNotSameAsArgument = preferences.includeInlayParameterNameHintsWhenArgumentMatchesName || !identifierOrAccessExpressionPostfixMatchesParameterName(arg, parameterName);
         if (!isParameterNameNotSameAsArgument && !isFirstVariadicArgument) {
           continue;
@@ -164716,7 +164798,7 @@ function provideInlayHints(context) {
         if (leadingCommentsContainsParameterName(arg, name)) {
           continue;
         }
-        addParameterHints(name, originalArg.getStart(), isFirstVariadicArgument);
+        addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument, sourceFile);
       }
     }
   }
@@ -164822,12 +164904,6 @@ function provideInlayHints(context) {
     }
     return printTypeInSingleLine(signatureParamType);
   }
-  function truncation(text, maxLength2) {
-    if (text.length > maxLength2) {
-      return text.substr(0, maxLength2 - "...".length) + "...";
-    }
-    return text;
-  }
   function printTypeInSingleLine(type) {
     const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
     const printer = createPrinterWithRemoveComments();
@@ -164858,6 +164934,13 @@ function provideInlayHints(context) {
     }
     return true;
   }
+  function getNodeDisplayPart(text, node, sourceFile) {
+    return {
+      text,
+      span: createTextSpanFromNode(node, sourceFile),
+      file: sourceFile.fileName
+    };
+  }
 }
 
 // src/services/_namespaces/ts.JsDoc.ts
@@ -167277,7 +167360,7 @@ function getSymbolModifiers(typeChecker, symbol) {
   }
   return modifiers.size > 0 ? arrayFrom(modifiers.values()).join(",") : "" /* none */;
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
+function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias) {
   var _a;
   const displayParts = [];
   let documentation = [];
@@ -167286,7 +167369,6 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
   let symbolKind = semanticMeaning & 1 /* Value */ ? getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) : "" /* unknown */;
   let hasAddedSymbolInfo = false;
   const isThisExpression = location.kind === 110 /* ThisKeyword */ && isInExpressionContext(location) || isThisInTypeQuery(location);
-  let type;
   let documentationFromAlias;
   let tagsFromAlias;
   let hasMultipleSignatures = false;
@@ -167315,7 +167397,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
       }
     }
     let signature;
-    type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+    type ?? (type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location));
     if (location.parent && location.parent.kind === 211 /* PropertyAccessExpression */) {
       const right = location.parent.name;
       if (right === location || right && right.getFullWidth() === 0) {
@@ -167530,12 +167612,13 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
         if (declarationName && !hasAddedSymbolInfo) {
           const isExternalModuleDeclaration = isModuleWithStringLiteralName(resolvedNode) && hasSyntacticModifier(resolvedNode, 2 /* Ambient */);
           const shouldUseAliasName = symbol.name !== "default" && !isExternalModuleDeclaration;
-          const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKind(
+          const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
             typeChecker,
             resolvedSymbol,
             getSourceFileOfNode(resolvedNode),
             resolvedNode,
             declarationName,
+            type,
             semanticMeaning,
             shouldUseAliasName ? symbol : resolvedSymbol
           );
@@ -167790,6 +167873,19 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
     addRange(displayParts, typeParameterParts);
   }
 }
+function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
+  return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
+    typeChecker,
+    symbol,
+    sourceFile,
+    enclosingDeclaration,
+    location,
+    /*type*/
+    void 0,
+    semanticMeaning,
+    alias
+  );
+}
 function isLocalVariableOrFunction(symbol) {
   if (symbol.parent) {
     return false;
@@ -172799,6 +172895,7 @@ __export(ts_exports2, {
   getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
+  getPropertyNameFromType: () => getPropertyNameFromType,
   getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
   getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
   getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
@@ -173631,6 +173728,7 @@ __export(ts_exports2, {
   isTypeQueryNode: () => isTypeQueryNode,
   isTypeReferenceNode: () => isTypeReferenceNode,
   isTypeReferenceType: () => isTypeReferenceType,
+  isTypeUsableAsPropertyName: () => isTypeUsableAsPropertyName,
   isUMDExportSymbol: () => isUMDExportSymbol,
   isUnaryExpression: () => isUnaryExpression,
   isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,
@@ -183489,10 +183587,22 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
     const { file, project } = this.getFileAndProject(args);
     const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
     const hints = project.getLanguageService().provideInlayHints(file, args, this.getPreferences(file));
-    return hints.map((hint) => ({
-      ...hint,
-      position: scriptInfo.positionToLineOffset(hint.position)
-    }));
+    return hints.map((hint) => {
+      const { text, position } = hint;
+      const hintText = typeof text === "string" ? text : text.map(({ text: text2, span, file: file2 }) => ({
+        text: text2,
+        span: span && {
+          start: scriptInfo.positionToLineOffset(span.start),
+          end: scriptInfo.positionToLineOffset(span.start + span.length),
+          file: file2
+        }
+      }));
+      return {
+        ...hint,
+        position: scriptInfo.positionToLineOffset(position),
+        text: hintText
+      };
+    });
   }
   setCompilerOptionsForInferredProjects(args) {
     this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);
@@ -187313,6 +187423,7 @@ start(initializeNodeSystem(), require("os").platform());
   getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol,
+  getPropertyNameFromType,
   getPropertyNameOfBindingOrAssignmentElement,
   getPropertySymbolFromBindingElement,
   getPropertySymbolsFromContextualType,
@@ -188145,6 +188256,7 @@ start(initializeNodeSystem(), require("os").platform());
   isTypeQueryNode,
   isTypeReferenceNode,
   isTypeReferenceType,
+  isTypeUsableAsPropertyName,
   isUMDExportSymbol,
   isUnaryExpression,
   isUnaryExpressionWithWrite,