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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.2";
-      version = `${versionMajorMinor}.0-insiders.20230718`;
+      version = `${versionMajorMinor}.0-insiders.20230725`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4576,7 +4576,8 @@ ${lanes.join("\n")}
         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 || {});
@@ -7972,9 +7973,6 @@ ${lanes.join("\n")}
         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}'."),
@@ -12455,7 +12453,6 @@ ${lanes.join("\n")}
       case 236 /* MetaProperty */:
       case 102 /* ImportKeyword */:
       case 282 /* MissingDeclaration */:
-      case 237 /* SyntheticExpression */:
         return true;
       default:
         return false;
@@ -19228,6 +19225,18 @@ ${lanes.join("\n")}
   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();
+  }
   var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashLibReferenceRegEx, fullTripleSlashAMDReferencePathRegEx, fullTripleSlashAMDModuleRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsNotSupportingExtensionlessResolution, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
@@ -33185,10 +33194,14 @@ ${lanes.join("\n")}
               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();
@@ -33553,14 +33566,14 @@ ${lanes.join("\n")}
         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);
         }
@@ -34078,6 +34091,9 @@ ${lanes.join("\n")}
         }
         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 */);
@@ -35861,7 +35877,7 @@ ${lanes.join("\n")}
       })(IncrementalParser || (IncrementalParser = {}));
       namedArgRegExCache = /* @__PURE__ */ new Map();
       tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im;
-      singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im;
+      singleLinePragmaRegEx = /^\/\/\/?\s*@([^\s:]+)(.*)\s*$/im;
     }
   });
 
@@ -41734,6 +41750,9 @@ ${lanes.join("\n")}
             if (found === 1 /* Instantiated */) {
               return found;
             }
+            if (statement.kind === 271 /* ImportEqualsDeclaration */) {
+              found = 1 /* Instantiated */;
+            }
           }
         }
         if (found !== void 0) {
@@ -45588,7 +45607,7 @@ ${lanes.join("\n")}
         return node ? getTypeFromTypeNode(node) : errorType;
       },
       getParameterType: getTypeAtPosition,
-      getParameterIdentifierNameAtPosition,
+      getParameterIdentifierInfoAtPosition,
       getPromisedTypeOfPromise,
       getAwaitedType: (type) => getAwaitedType(type),
       getReturnTypeOfSignature,
@@ -46341,7 +46360,6 @@ ${lanes.join("\n")}
     var potentialReflectCollisions = [];
     var potentialUnusedRenamedBindingElementsInTypes = [];
     var awaitedTypeStack = [];
-    var hasGlobalSymbolHasInstanceProperty;
     var diagnostics = createDiagnosticCollection();
     var suggestionDiagnostics = createDiagnosticCollection();
     var typeofType = createTypeofType();
@@ -47030,7 +47048,7 @@ ${lanes.join("\n")}
           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;
           }
@@ -48646,7 +48664,7 @@ ${lanes.join("\n")}
       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/");
@@ -48681,8 +48699,11 @@ ${lanes.join("\n")}
             );
           }
         } 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)) {
@@ -48699,7 +48720,7 @@ ${lanes.join("\n")}
           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);
@@ -48802,7 +48823,7 @@ ${lanes.join("\n")}
             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,
@@ -50238,11 +50259,13 @@ ${lanes.join("\n")}
           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"));
@@ -50250,6 +50273,11 @@ ${lanes.join("\n")}
               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);
           }
@@ -50280,6 +50308,18 @@ ${lanes.join("\n")}
               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;
         }
@@ -54052,7 +54092,7 @@ ${lanes.join("\n")}
         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;
       }
@@ -55331,9 +55371,6 @@ ${lanes.join("\n")}
       }
       return type;
     }
-    function isTypeUsableAsPropertyName(type) {
-      return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
-    }
     function isLateBindableName(node) {
       if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
         return false;
@@ -55354,15 +55391,6 @@ ${lanes.join("\n")}
     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;
@@ -55412,6 +55440,7 @@ ${lanes.join("\n")}
       return links.resolvedSymbol;
     }
     function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
+      var _a, _b, _c;
       const links = getSymbolLinks(symbol);
       if (!links[resolutionKind]) {
         const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
@@ -55430,7 +55459,7 @@ ${lanes.join("\n")}
             }
           }
         }
-        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) {
@@ -55559,7 +55588,7 @@ ${lanes.join("\n")}
         /*resolvedTypePredicate*/
         void 0,
         sig.minArgumentCount,
-        sig.flags & 39 /* PropagatingFlags */
+        sig.flags & 167 /* PropagatingFlags */
       );
       result.target = sig.target;
       result.mapper = sig.mapper;
@@ -55860,7 +55889,7 @@ ${lanes.join("\n")}
         /*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]);
@@ -56008,20 +56037,17 @@ ${lanes.join("\n")}
         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);
@@ -56070,7 +56096,7 @@ ${lanes.join("\n")}
               /*resolvedTypePredicate*/
               void 0,
               sig.minArgumentCount,
-              sig.flags & 39 /* PropagatingFlags */
+              sig.flags & 167 /* PropagatingFlags */
             ) : void 0
           ));
         }
@@ -60853,7 +60879,7 @@ ${lanes.join("\n")}
         /*resolvedTypePredicate*/
         void 0,
         signature.minArgumentCount,
-        signature.flags & 39 /* PropagatingFlags */
+        signature.flags & 167 /* PropagatingFlags */
       );
       result.target = signature;
       result.mapper = mapper;
@@ -68114,12 +68140,15 @@ ${lanes.join("\n")}
               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);
               }
             }
@@ -68384,15 +68413,6 @@ ${lanes.join("\n")}
           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;
         }
@@ -68472,12 +68492,8 @@ ${lanes.join("\n")}
       }
       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,
@@ -69730,41 +69746,75 @@ ${lanes.join("\n")}
       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);
             }
-            return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+            if (concretePropertyTypes) {
+              return getIntersectionType(concatenate(concretePropertyTypes, applicableIndexedMappedTypeSubstitions));
+            }
+            const types = concatenate(mapDefined(applicableIndexInfoCandidates, getTypeOfApplicableIndexInfoOfContextualType), applicableIndexedMappedTypeSubstitions);
+            if (types.length > 0) {
+              return getIntersectionType(types);
+            }
+            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));
@@ -70315,7 +70365,7 @@ ${lanes.join("\n")}
         /*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]);
@@ -73054,7 +73104,7 @@ ${lanes.join("\n")}
       }
       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);
@@ -73097,7 +73147,6 @@ ${lanes.join("\n")}
               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);
             }
@@ -73165,7 +73214,6 @@ ${lanes.join("\n")}
               map(diags, createDiagnosticMessageChainFromDiagnostic),
               Diagnostics.No_overload_matches_this_call
             );
-            const headMessage = headMessageCallback == null ? void 0 : headMessageCallback();
             if (headMessage) {
               chain = chainDiagnosticMessages(chain, headMessage);
             }
@@ -73181,21 +73229,21 @@ ${lanes.join("\n")}
             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));
           }
         }
       }
@@ -73346,7 +73394,7 @@ ${lanes.join("\n")}
         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));
@@ -73503,7 +73551,7 @@ ${lanes.join("\n")}
         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)));
@@ -73800,7 +73848,7 @@ ${lanes.join("\n")}
         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);
@@ -74070,6 +74118,8 @@ ${lanes.join("\n")}
       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));
@@ -74543,7 +74593,7 @@ ${lanes.join("\n")}
       }
       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;
@@ -74551,10 +74601,16 @@ ${lanes.join("\n")}
       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);
@@ -74563,18 +74619,19 @@ ${lanes.join("\n")}
         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);
@@ -75833,32 +75890,6 @@ ${lanes.join("\n")}
     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;
@@ -75866,31 +75897,8 @@ ${lanes.join("\n")}
       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;
     }
@@ -125259,7 +125267,6 @@ ${lanes.join("\n")}
       if (hasChangedCompilerOptions) {
         newLine = updateNewLine();
         if (program && changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
-          debugger;
           resolutionCache.onChangesAffectModuleResolution();
         }
       }
@@ -134477,8 +134484,8 @@ ${lanes.join("\n")}
             diags.push(createDiagnosticForNode(init, Diagnostics.require_call_may_be_converted_to_an_import));
           }
         }
-        const jsdocTypedefNode = ts_codefix_exports.getJSDocTypedefNode(node);
-        if (jsdocTypedefNode) {
+        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)) {
@@ -148406,23 +148413,60 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   });
 
   // src/services/codefixes/convertTypedefToType.ts
-  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;
@@ -148443,7 +148487,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const propertySignatures = createSignatureFromTypeLiteral(typeLiteral);
     if (!some(propertySignatures))
       return;
-    const interfaceDeclaration = factory.createInterfaceDeclaration(
+    return factory.createInterfaceDeclaration(
       /*modifiers*/
       void 0,
       typeName,
@@ -148453,13 +148497,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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),
@@ -148467,7 +148510,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       void 0,
       typeReference
     );
-    return declaration;
   }
   function createSignatureFromTypeLiteral(typeLiteral) {
     const propertyTags = typeLiteral.jsDocPropertyTags;
@@ -148487,30 +148529,28 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       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 [];
   }
   var fixId14, errorCodes15;
   var init_convertTypedefToType = __esm({
@@ -148524,13 +148564,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         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(
@@ -148543,11 +148584,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             ];
           }
         },
-        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);
+          }
+        )
       });
     }
   });
@@ -149645,6 +149692,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     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) {
@@ -150822,6 +150877,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         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;
@@ -154247,15 +154304,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   }
   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 */;
@@ -154406,6 +154459,19 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         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;
@@ -156061,7 +156127,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     getFixes: () => getFixes,
     getImportCompletionAction: () => getImportCompletionAction,
     getImportKind: () => getImportKind,
-    getJSDocTypedefNode: () => getJSDocTypedefNode,
+    getJSDocTypedefNodes: () => getJSDocTypedefNodes,
     getNoopSymbolTrackerWithResolver: () => getNoopSymbolTrackerWithResolver,
     getPromoteTypeOnlyCompletionAction: () => getPromoteTypeOnlyCompletionAction,
     getSupportedErrorCodes: () => getSupportedErrorCodes,
@@ -158440,7 +158506,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         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;
@@ -158470,6 +158537,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
           }
         } else if (preferences.includeCompletionsWithInsertText) {
+          if (firstAccessibleSymbolId && seenPropertySymbols.has(firstAccessibleSymbolId)) {
+            return;
+          }
           addSymbolOriginInfo(symbol);
           addSymbolSortInfo(symbol);
           symbols.push(symbol);
@@ -163933,6 +164003,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   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;
@@ -163983,9 +164056,15 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     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
@@ -163993,7 +164072,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     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
@@ -164001,7 +164080,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     function addEnumMemberValueHints(text, position) {
       result.push({
-        text: `= ${truncation(text, maxHintsLength)}`,
+        text: `= ${text}`,
         position,
         kind: "Enum" /* Enum */,
         whitespaceBefore: true
@@ -164051,6 +164130,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         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)) {
@@ -164071,10 +164151,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
           }
         }
-        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;
@@ -164083,7 +164163,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (leadingCommentsContainsParameterName(arg, name)) {
             continue;
           }
-          addParameterHints(name, originalArg.getStart(), isFirstVariadicArgument);
+          addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument, sourceFile);
         }
       }
     }
@@ -164189,12 +164269,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       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();
@@ -164225,13 +164299,20 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       return true;
     }
+    function getNodeDisplayPart(text, node, sourceFile) {
+      return {
+        text,
+        span: createTextSpanFromNode(node, sourceFile),
+        file: sourceFile.fileName
+      };
+    }
   }
-  var maxHintsLength, leadingParameterNameCommentRegexFactory;
+  var maxTypeHintLength, leadingParameterNameCommentRegexFactory;
   var init_inlayHints = __esm({
     "src/services/inlayHints.ts"() {
       "use strict";
       init_ts4();
-      maxHintsLength = 30;
+      maxTypeHintLength = 30;
       leadingParameterNameCommentRegexFactory = (name) => {
         return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
       };
@@ -166733,7 +166814,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     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 = [];
@@ -166742,7 +166823,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     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;
@@ -166771,7 +166851,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       }
       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) {
@@ -166986,12 +167066,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           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
             );
@@ -167246,6 +167327,19 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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;
@@ -172561,6 +172655,7 @@ ${options.prefix}` : "\n" : options.prefix
     getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
     getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
     getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
+    getPropertyNameFromType: () => getPropertyNameFromType,
     getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
     getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
     getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
@@ -173393,6 +173488,7 @@ ${options.prefix}` : "\n" : options.prefix
     isTypeQueryNode: () => isTypeQueryNode,
     isTypeReferenceNode: () => isTypeReferenceNode,
     isTypeReferenceType: () => isTypeReferenceType,
+    isTypeUsableAsPropertyName: () => isTypeUsableAsPropertyName,
     isUMDExportSymbol: () => isUMDExportSymbol,
     isUnaryExpression: () => isUnaryExpression,
     isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,