typescript 5.5.0-dev.20240326 → 5.5.0-dev.20240328

package/lib/typescript.js

@@ -402,6 +402,7 @@ __export(typescript_exports, {
   createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
   createEmitHelperFactory: () => createEmitHelperFactory,
   createEmptyExports: () => createEmptyExports,
+  createEvaluator: () => createEvaluator,
   createExpressionForJsxElement: () => createExpressionForJsxElement,
   createExpressionForJsxFragment: () => createExpressionForJsxFragment,
   createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
@@ -1466,6 +1467,7 @@ __export(typescript_exports, {
   isJSDocEnumTag: () => isJSDocEnumTag,
   isJSDocFunctionType: () => isJSDocFunctionType,
   isJSDocImplementsTag: () => isJSDocImplementsTag,
+  isJSDocImportTag: () => isJSDocImportTag,
   isJSDocIndexSignature: () => isJSDocIndexSignature,
   isJSDocLikeText: () => isJSDocLikeText,
   isJSDocLink: () => isJSDocLink,
@@ -2326,7 +2328,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240326`;
+var version = `${versionMajorMinor}.0-dev.20240328`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6071,12 +6073,13 @@ var SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => {
   SyntaxKind5[SyntaxKind5["JSDocPropertyTag"] = 348] = "JSDocPropertyTag";
   SyntaxKind5[SyntaxKind5["JSDocThrowsTag"] = 349] = "JSDocThrowsTag";
   SyntaxKind5[SyntaxKind5["JSDocSatisfiesTag"] = 350] = "JSDocSatisfiesTag";
-  SyntaxKind5[SyntaxKind5["SyntaxList"] = 351] = "SyntaxList";
-  SyntaxKind5[SyntaxKind5["NotEmittedStatement"] = 352] = "NotEmittedStatement";
-  SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 353] = "PartiallyEmittedExpression";
-  SyntaxKind5[SyntaxKind5["CommaListExpression"] = 354] = "CommaListExpression";
-  SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 355] = "SyntheticReferenceExpression";
-  SyntaxKind5[SyntaxKind5["Count"] = 356] = "Count";
+  SyntaxKind5[SyntaxKind5["JSDocImportTag"] = 351] = "JSDocImportTag";
+  SyntaxKind5[SyntaxKind5["SyntaxList"] = 352] = "SyntaxList";
+  SyntaxKind5[SyntaxKind5["NotEmittedStatement"] = 353] = "NotEmittedStatement";
+  SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 354] = "PartiallyEmittedExpression";
+  SyntaxKind5[SyntaxKind5["CommaListExpression"] = 355] = "CommaListExpression";
+  SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 356] = "SyntheticReferenceExpression";
+  SyntaxKind5[SyntaxKind5["Count"] = 357] = "Count";
   SyntaxKind5[SyntaxKind5["FirstAssignment"] = 64 /* EqualsToken */] = "FirstAssignment";
   SyntaxKind5[SyntaxKind5["LastAssignment"] = 79 /* CaretEqualsToken */] = "LastAssignment";
   SyntaxKind5[SyntaxKind5["FirstCompoundAssignment"] = 65 /* PlusEqualsToken */] = "FirstCompoundAssignment";
@@ -6105,9 +6108,9 @@ var SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => {
   SyntaxKind5[SyntaxKind5["LastStatement"] = 259 /* DebuggerStatement */] = "LastStatement";
   SyntaxKind5[SyntaxKind5["FirstNode"] = 166 /* QualifiedName */] = "FirstNode";
   SyntaxKind5[SyntaxKind5["FirstJSDocNode"] = 309 /* JSDocTypeExpression */] = "FirstJSDocNode";
-  SyntaxKind5[SyntaxKind5["LastJSDocNode"] = 350 /* JSDocSatisfiesTag */] = "LastJSDocNode";
+  SyntaxKind5[SyntaxKind5["LastJSDocNode"] = 351 /* JSDocImportTag */] = "LastJSDocNode";
   SyntaxKind5[SyntaxKind5["FirstJSDocTagNode"] = 327 /* JSDocTag */] = "FirstJSDocTagNode";
-  SyntaxKind5[SyntaxKind5["LastJSDocTagNode"] = 350 /* JSDocSatisfiesTag */] = "LastJSDocTagNode";
+  SyntaxKind5[SyntaxKind5["LastJSDocTagNode"] = 351 /* JSDocImportTag */] = "LastJSDocTagNode";
   SyntaxKind5[SyntaxKind5["FirstContextualKeyword"] = 128 /* AbstractKeyword */] = "FirstContextualKeyword";
   SyntaxKind5[SyntaxKind5["LastContextualKeyword"] = 165 /* OfKeyword */] = "LastContextualKeyword";
   return SyntaxKind5;
@@ -6693,6 +6696,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
   ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
   ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
+  ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
   ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -12042,7 +12046,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   var tokenValue;
   var tokenFlags;
   var commentDirectives;
-  var inJSDocType = 0;
+  var skipJsDocLeadingAsterisks = 0;
   var scriptKind = 0 /* Unknown */;
   var jsDocParsingMode = 0 /* ParseAll */;
   setText(text, start, length2);
@@ -12093,7 +12097,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     setOnError,
     resetTokenState,
     setTextPos: resetTokenState,
-    setInJSDocType,
+    setSkipJsDocLeadingAsterisks,
     tryScan,
     lookAhead,
     scanRange
@@ -12809,7 +12813,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             return pos += 2, token = 43 /* AsteriskAsteriskToken */;
           }
           pos++;
-          if (inJSDocType && !asteriskSeen && tokenFlags & 1 /* PrecedingLineBreak */) {
+          if (skipJsDocLeadingAsterisks && !asteriskSeen && tokenFlags & 1 /* PrecedingLineBreak */) {
             asteriskSeen = true;
             continue;
           }
@@ -13587,8 +13591,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     tokenValue = void 0;
     tokenFlags = 0 /* None */;
   }
-  function setInJSDocType(inType) {
-    inJSDocType += inType ? 1 : -1;
+  function setSkipJsDocLeadingAsterisks(skip) {
+    skipJsDocLeadingAsterisks += skip ? 1 : -1;
   }
 }
 function codePointAt(s, i) {
@@ -14791,8 +14795,8 @@ function isExpressionKind(kind) {
     case 230 /* SpreadElement */:
     case 234 /* AsExpression */:
     case 232 /* OmittedExpression */:
-    case 354 /* CommaListExpression */:
-    case 353 /* PartiallyEmittedExpression */:
+    case 355 /* CommaListExpression */:
+    case 354 /* PartiallyEmittedExpression */:
     case 238 /* SatisfiesExpression */:
       return true;
     default:
@@ -14977,7 +14981,7 @@ function isDeclarationStatementKind(kind) {
   return kind === 262 /* FunctionDeclaration */ || kind === 282 /* MissingDeclaration */ || kind === 263 /* ClassDeclaration */ || kind === 264 /* InterfaceDeclaration */ || kind === 265 /* TypeAliasDeclaration */ || kind === 266 /* EnumDeclaration */ || kind === 267 /* ModuleDeclaration */ || kind === 272 /* ImportDeclaration */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 278 /* ExportDeclaration */ || kind === 277 /* ExportAssignment */ || kind === 270 /* NamespaceExportDeclaration */;
 }
 function isStatementKindButNotDeclarationKind(kind) {
-  return kind === 252 /* BreakStatement */ || kind === 251 /* ContinueStatement */ || kind === 259 /* DebuggerStatement */ || kind === 246 /* DoStatement */ || kind === 244 /* ExpressionStatement */ || kind === 242 /* EmptyStatement */ || kind === 249 /* ForInStatement */ || kind === 250 /* ForOfStatement */ || kind === 248 /* ForStatement */ || kind === 245 /* IfStatement */ || kind === 256 /* LabeledStatement */ || kind === 253 /* ReturnStatement */ || kind === 255 /* SwitchStatement */ || kind === 257 /* ThrowStatement */ || kind === 258 /* TryStatement */ || kind === 243 /* VariableStatement */ || kind === 247 /* WhileStatement */ || kind === 254 /* WithStatement */ || kind === 352 /* NotEmittedStatement */;
+  return kind === 252 /* BreakStatement */ || kind === 251 /* ContinueStatement */ || kind === 259 /* DebuggerStatement */ || kind === 246 /* DoStatement */ || kind === 244 /* ExpressionStatement */ || kind === 242 /* EmptyStatement */ || kind === 249 /* ForInStatement */ || kind === 250 /* ForOfStatement */ || kind === 248 /* ForStatement */ || kind === 245 /* IfStatement */ || kind === 256 /* LabeledStatement */ || kind === 253 /* ReturnStatement */ || kind === 255 /* SwitchStatement */ || kind === 257 /* ThrowStatement */ || kind === 258 /* TryStatement */ || kind === 243 /* VariableStatement */ || kind === 247 /* WhileStatement */ || kind === 254 /* WithStatement */ || kind === 353 /* NotEmittedStatement */;
 }
 function isDeclaration(node) {
   if (node.kind === 168 /* TypeParameter */) {
@@ -15038,13 +15042,13 @@ function isCaseOrDefaultClause(node) {
   return kind === 296 /* CaseClause */ || kind === 297 /* DefaultClause */;
 }
 function isJSDocNode(node) {
-  return node.kind >= 309 /* FirstJSDocNode */ && node.kind <= 350 /* LastJSDocNode */;
+  return node.kind >= 309 /* FirstJSDocNode */ && node.kind <= 351 /* LastJSDocNode */;
 }
 function isJSDocCommentContainingNode(node) {
   return node.kind === 320 /* JSDoc */ || node.kind === 319 /* JSDocNamepathType */ || node.kind === 321 /* JSDocText */ || isJSDocLinkLike(node) || isJSDocTag(node) || isJSDocTypeLiteral(node) || isJSDocSignature(node);
 }
 function isJSDocTag(node) {
-  return node.kind >= 327 /* FirstJSDocTagNode */ && node.kind <= 350 /* LastJSDocTagNode */;
+  return node.kind >= 327 /* FirstJSDocTagNode */ && node.kind <= 351 /* LastJSDocTagNode */;
 }
 function isSetAccessor(node) {
   return node.kind === 178 /* SetAccessor */;
@@ -15542,7 +15546,7 @@ function getTokenPosOfNode(node, sourceFile, includeJsDoc) {
   if (includeJsDoc && hasJSDocNodes(node)) {
     return getTokenPosOfNode(node.jsDoc[0], sourceFile);
   }
-  if (node.kind === 351 /* SyntaxList */ && node._children.length > 0) {
+  if (node.kind === 352 /* SyntaxList */ && node._children.length > 0) {
     return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc);
   }
   return skipTrivia(
@@ -17578,6 +17582,7 @@ function tryGetModuleSpecifierFromDeclaration(node) {
       ))) == null ? void 0 : _a.arguments[0];
     case 272 /* ImportDeclaration */:
     case 278 /* ExportDeclaration */:
+    case 351 /* JSDocImportTag */:
       return tryCast(node.moduleSpecifier, isStringLiteralLike);
     case 271 /* ImportEqualsDeclaration */:
       return tryCast((_b = tryCast(node.moduleReference, isExternalModuleReference)) == null ? void 0 : _b.expression, isStringLiteralLike);
@@ -17602,6 +17607,7 @@ function tryGetImportFromModuleSpecifier(node) {
   switch (node.parent.kind) {
     case 272 /* ImportDeclaration */:
     case 278 /* ExportDeclaration */:
+    case 351 /* JSDocImportTag */:
       return node.parent;
     case 283 /* ExternalModuleReference */:
       return node.parent.parent;
@@ -17622,6 +17628,7 @@ function getExternalModuleName(node) {
   switch (node.kind) {
     case 272 /* ImportDeclaration */:
     case 278 /* ExportDeclaration */:
+    case 351 /* JSDocImportTag */:
       return node.moduleSpecifier;
     case 271 /* ImportEqualsDeclaration */:
       return node.moduleReference.kind === 283 /* ExternalModuleReference */ ? node.moduleReference.expression : void 0;
@@ -17648,7 +17655,7 @@ function getNamespaceDeclarationNode(node) {
   }
 }
 function isDefaultImport(node) {
-  return node.kind === 272 /* ImportDeclaration */ && !!node.importClause && !!node.importClause.name;
+  return (node.kind === 272 /* ImportDeclaration */ || node.kind === 351 /* JSDocImportTag */) && !!node.importClause && !!node.importClause.name;
 }
 function forEachImportClauseDeclaration(node, action) {
   if (node.name) {
@@ -18538,7 +18545,7 @@ var OperatorPrecedence = /* @__PURE__ */ ((OperatorPrecedence2) => {
 })(OperatorPrecedence || {});
 function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
   switch (nodeKind) {
-    case 354 /* CommaListExpression */:
+    case 355 /* CommaListExpression */:
       return 0 /* Comma */;
     case 230 /* SpreadElement */:
       return 1 /* Spread */;
@@ -20235,7 +20242,7 @@ function getLeftmostExpression(node, stopAtCallExpressions) {
       case 212 /* ElementAccessExpression */:
       case 211 /* PropertyAccessExpression */:
       case 235 /* NonNullExpression */:
-      case 353 /* PartiallyEmittedExpression */:
+      case 354 /* PartiallyEmittedExpression */:
       case 238 /* SatisfiesExpression */:
         node = node.expression;
         continue;
@@ -21677,7 +21684,7 @@ function getContainingNodeArray(node) {
       return parent2.types;
     case 189 /* TupleType */:
     case 209 /* ArrayLiteralExpression */:
-    case 354 /* CommaListExpression */:
+    case 355 /* CommaListExpression */:
     case 275 /* NamedImports */:
     case 279 /* NamedExports */:
       return parent2.elements;
@@ -21930,6 +21937,91 @@ function isSyntacticallyString(expr) {
   }
   return false;
 }
+function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression }) {
+  function evaluate(expr, location) {
+    switch (expr.kind) {
+      case 224 /* PrefixUnaryExpression */:
+        const value = evaluate(expr.operand, location);
+        if (typeof value === "number") {
+          switch (expr.operator) {
+            case 40 /* PlusToken */:
+              return value;
+            case 41 /* MinusToken */:
+              return -value;
+            case 55 /* TildeToken */:
+              return ~value;
+          }
+        }
+        break;
+      case 226 /* BinaryExpression */:
+        const left = evaluate(expr.left, location);
+        const right = evaluate(expr.right, location);
+        if (typeof left === "number" && typeof right === "number") {
+          switch (expr.operatorToken.kind) {
+            case 52 /* BarToken */:
+              return left | right;
+            case 51 /* AmpersandToken */:
+              return left & right;
+            case 49 /* GreaterThanGreaterThanToken */:
+              return left >> right;
+            case 50 /* GreaterThanGreaterThanGreaterThanToken */:
+              return left >>> right;
+            case 48 /* LessThanLessThanToken */:
+              return left << right;
+            case 53 /* CaretToken */:
+              return left ^ right;
+            case 42 /* AsteriskToken */:
+              return left * right;
+            case 44 /* SlashToken */:
+              return left / right;
+            case 40 /* PlusToken */:
+              return left + right;
+            case 41 /* MinusToken */:
+              return left - right;
+            case 45 /* PercentToken */:
+              return left % right;
+            case 43 /* AsteriskAsteriskToken */:
+              return left ** right;
+          }
+        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
+          return "" + left + right;
+        }
+        break;
+      case 11 /* StringLiteral */:
+      case 15 /* NoSubstitutionTemplateLiteral */:
+        return expr.text;
+      case 228 /* TemplateExpression */:
+        return evaluateTemplateExpression(expr, location);
+      case 9 /* NumericLiteral */:
+        return +expr.text;
+      case 217 /* ParenthesizedExpression */:
+        return evaluate(expr.expression, location);
+      case 80 /* Identifier */:
+        return evaluateEntityNameExpression(expr, location);
+      case 211 /* PropertyAccessExpression */:
+        if (isEntityNameExpression(expr)) {
+          return evaluateEntityNameExpression(expr, location);
+        }
+        break;
+      case 212 /* ElementAccessExpression */:
+        return evaluateElementAccessExpression(expr, location);
+    }
+    return void 0;
+  }
+  function evaluateTemplateExpression(expr, location) {
+    let result = expr.head.text;
+    for (const span of expr.templateSpans) {
+      const value = evaluate(span.expression, location);
+      if (value === void 0) {
+        return void 0;
+      }
+      result += value;
+      result += span.literal.text;
+    }
+    return result;
+  }
+  return evaluate;
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -22804,7 +22896,7 @@ function createNodeFactory(flags, baseFactory2) {
     updateImportEqualsDeclaration,
     createImportDeclaration,
     updateImportDeclaration,
-    createImportClause,
+    createImportClause: createImportClause2,
     updateImportClause,
     createAssertClause,
     updateAssertClause,
@@ -22898,6 +22990,8 @@ function createNodeFactory(flags, baseFactory2) {
     updateJSDocImplementsTag,
     createJSDocSeeTag,
     updateJSDocSeeTag,
+    createJSDocImportTag,
+    updateJSDocImportTag,
     createJSDocNameReference,
     updateJSDocNameReference,
     createJSDocMemberName,
@@ -25237,7 +25331,7 @@ function createNodeFactory(flags, baseFactory2) {
   function updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, attributes) {
     return node.modifiers !== modifiers || node.importClause !== importClause || node.moduleSpecifier !== moduleSpecifier || node.attributes !== attributes ? update(createImportDeclaration(modifiers, importClause, moduleSpecifier, attributes), node) : node;
   }
-  function createImportClause(isTypeOnly, name, namedBindings) {
+  function createImportClause2(isTypeOnly, name, namedBindings) {
     const node = createBaseDeclaration(273 /* ImportClause */);
     node.isTypeOnly = isTypeOnly;
     node.name = name;
@@ -25250,7 +25344,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function updateImportClause(node, isTypeOnly, name, namedBindings) {
-    return node.isTypeOnly !== isTypeOnly || node.name !== name || node.namedBindings !== namedBindings ? update(createImportClause(isTypeOnly, name, namedBindings), node) : node;
+    return node.isTypeOnly !== isTypeOnly || node.name !== name || node.namedBindings !== namedBindings ? update(createImportClause2(isTypeOnly, name, namedBindings), node) : node;
   }
   function createAssertClause(elements, multiLine) {
     const node = createBaseNode(300 /* AssertClause */);
@@ -25670,6 +25764,17 @@ function createNodeFactory(flags, baseFactory2) {
   function updateJSDocEnumTag(node, tagName = getDefaultTagName(node), typeExpression, comment) {
     return node.tagName !== tagName || node.typeExpression !== typeExpression || node.comment !== comment ? update(createJSDocEnumTag(tagName, typeExpression, comment), node) : node;
   }
+  function createJSDocImportTag(tagName, importClause, moduleSpecifier, attributes, comment) {
+    const node = createBaseJSDocTag(351 /* JSDocImportTag */, tagName ?? createIdentifier("import"), comment);
+    node.importClause = importClause;
+    node.moduleSpecifier = moduleSpecifier;
+    node.attributes = attributes;
+    node.comment = comment;
+    return node;
+  }
+  function updateJSDocImportTag(node, tagName, importClause, moduleSpecifier, attributes, comment) {
+    return node.tagName !== tagName || node.comment !== comment || node.importClause !== importClause || node.moduleSpecifier !== moduleSpecifier || node.attributes !== attributes ? update(createJSDocImportTag(tagName, importClause, moduleSpecifier, attributes, comment), node) : node;
+  }
   function createJSDocText(text) {
     const node = createBaseNode(321 /* JSDocText */);
     node.text = text;
@@ -26067,18 +26172,18 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function createSyntaxList3(children) {
-    const node = createBaseNode(351 /* SyntaxList */);
+    const node = createBaseNode(352 /* SyntaxList */);
     node._children = children;
     return node;
   }
   function createNotEmittedStatement(original) {
-    const node = createBaseNode(352 /* NotEmittedStatement */);
+    const node = createBaseNode(353 /* NotEmittedStatement */);
     node.original = original;
     setTextRange(node, original);
     return node;
   }
   function createPartiallyEmittedExpression(expression, original) {
-    const node = createBaseNode(353 /* PartiallyEmittedExpression */);
+    const node = createBaseNode(354 /* PartiallyEmittedExpression */);
     node.expression = expression;
     node.original = original;
     node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
@@ -26100,7 +26205,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function createCommaListExpression(elements) {
-    const node = createBaseNode(354 /* CommaListExpression */);
+    const node = createBaseNode(355 /* CommaListExpression */);
     node.elements = createNodeArray(sameFlatMap(elements, flattenCommaElements));
     node.transformFlags |= propagateChildrenFlags(node.elements);
     return node;
@@ -26109,7 +26214,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node.elements !== elements ? update(createCommaListExpression(elements), node) : node;
   }
   function createSyntheticReferenceExpression(expression, thisArg) {
-    const node = createBaseNode(355 /* SyntheticReferenceExpression */);
+    const node = createBaseNode(356 /* SyntheticReferenceExpression */);
     node.expression = expression;
     node.thisArg = thisArg;
     node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thisArg);
@@ -26355,7 +26460,7 @@ function createNodeFactory(flags, baseFactory2) {
         return updateSatisfiesExpression(outerExpression, expression, outerExpression.type);
       case 235 /* NonNullExpression */:
         return updateNonNullExpression(outerExpression, expression);
-      case 353 /* PartiallyEmittedExpression */:
+      case 354 /* PartiallyEmittedExpression */:
         return updatePartiallyEmittedExpression(outerExpression, expression);
     }
   }
@@ -26765,6 +26870,8 @@ function getDefaultTagNameForKind(kind) {
       return "augments";
     case 329 /* JSDocImplementsTag */:
       return "implements";
+    case 351 /* JSDocImportTag */:
+      return "import";
     default:
       return Debug.fail(`Unsupported kind: ${Debug.formatSyntaxKind(kind)}`);
   }
@@ -26905,7 +27012,7 @@ function getTransformFlagsSubtreeExclusions(kind) {
     case 216 /* TypeAssertionExpression */:
     case 238 /* SatisfiesExpression */:
     case 234 /* AsExpression */:
-    case 353 /* PartiallyEmittedExpression */:
+    case 354 /* PartiallyEmittedExpression */:
     case 217 /* ParenthesizedExpression */:
     case 108 /* SuperKeyword */:
       return -2147483648 /* OuterExpressionExcludes */;
@@ -28617,10 +28724,10 @@ function isSyntheticExpression(node) {
   return node.kind === 237 /* SyntheticExpression */;
 }
 function isPartiallyEmittedExpression(node) {
-  return node.kind === 353 /* PartiallyEmittedExpression */;
+  return node.kind === 354 /* PartiallyEmittedExpression */;
 }
 function isCommaListExpression(node) {
-  return node.kind === 354 /* CommaListExpression */;
+  return node.kind === 355 /* CommaListExpression */;
 }
 function isTemplateSpan(node) {
   return node.kind === 239 /* TemplateSpan */;
@@ -28770,10 +28877,10 @@ function isMissingDeclaration(node) {
   return node.kind === 282 /* MissingDeclaration */;
 }
 function isNotEmittedStatement(node) {
-  return node.kind === 352 /* NotEmittedStatement */;
+  return node.kind === 353 /* NotEmittedStatement */;
 }
 function isSyntheticReference(node) {
-  return node.kind === 355 /* SyntheticReferenceExpression */;
+  return node.kind === 356 /* SyntheticReferenceExpression */;
 }
 function isExternalModuleReference(node) {
   return node.kind === 283 /* ExternalModuleReference */;
@@ -28967,8 +29074,11 @@ function isJSDocSatisfiesTag(node) {
 function isJSDocThrowsTag(node) {
   return node.kind === 349 /* JSDocThrowsTag */;
 }
+function isJSDocImportTag(node) {
+  return node.kind === 351 /* JSDocImportTag */;
+}
 function isSyntaxList(n) {
-  return n.kind === 351 /* SyntaxList */;
+  return n.kind === 352 /* SyntaxList */;
 }
 
 // src/compiler/factory/utilities.ts
@@ -29363,7 +29473,7 @@ function isOuterExpression(node, kinds = 15 /* All */) {
       return (kinds & 2 /* TypeAssertions */) !== 0;
     case 235 /* NonNullExpression */:
       return (kinds & 4 /* NonNullAssertions */) !== 0;
-    case 353 /* PartiallyEmittedExpression */:
+    case 354 /* PartiallyEmittedExpression */:
       return (kinds & 8 /* PartiallyEmittedExpressions */) !== 0;
   }
   return false;
@@ -30454,7 +30564,7 @@ var forEachChildTable = {
   [282 /* MissingDeclaration */]: function forEachChildInMissingDeclaration(node, cbNode, cbNodes) {
     return visitNodes(cbNode, cbNodes, node.modifiers);
   },
-  [354 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
+  [355 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
     return visitNodes(cbNode, cbNodes, node.elements);
   },
   [284 /* JsxElement */]: function forEachChildInJsxElement(node, cbNode, cbNodes) {
@@ -30549,7 +30659,8 @@ var forEachChildTable = {
   [336 /* JSDocReadonlyTag */]: forEachChildInJSDocTag,
   [331 /* JSDocDeprecatedTag */]: forEachChildInJSDocTag,
   [337 /* JSDocOverrideTag */]: forEachChildInJSDocTag,
-  [353 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
+  [351 /* JSDocImportTag */]: forEachChildInJSDocImportTag,
+  [354 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
 };
 function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) {
   return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
@@ -30600,6 +30711,9 @@ function forEachChildInJSDocLinkCodeOrPlain(node, cbNode, _cbNodes) {
 function forEachChildInJSDocTag(node, cbNode, cbNodes) {
   return visitNode2(cbNode, node.tagName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
 }
+function forEachChildInJSDocImportTag(node, cbNode, cbNodes) {
+  return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.importClause) || visitNode2(cbNode, node.moduleSpecifier) || visitNode2(cbNode, node.attributes) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
+}
 function forEachChildInPartiallyEmittedExpression(node, cbNode, _cbNodes) {
   return visitNode2(cbNode, node.expression);
 }
@@ -32607,7 +32721,7 @@ var Parser;
     );
   }
   function parseJSDocType() {
-    scanner2.setInJSDocType(true);
+    scanner2.setSkipJsDocLeadingAsterisks(true);
     const pos = getNodePos();
     if (parseOptional(144 /* ModuleKeyword */)) {
       const moduleTag = factory2.createJSDocNamepathType(
@@ -32626,12 +32740,12 @@ var Parser;
               nextTokenJSDoc();
           }
         }
-      scanner2.setInJSDocType(false);
+      scanner2.setSkipJsDocLeadingAsterisks(false);
       return finishNode(moduleTag, pos);
     }
     const hasDotDotDot = parseOptional(26 /* DotDotDotToken */);
     let type = parseTypeOrTypePredicate();
-    scanner2.setInJSDocType(false);
+    scanner2.setSkipJsDocLeadingAsterisks(false);
     if (hasDotDotDot) {
       type = finishNode(factory2.createJSDocVariadicType(type), pos);
     }
@@ -36194,22 +36308,28 @@ var Parser;
     if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
       return parseImportEqualsDeclaration(pos, hasJSDoc, modifiers, identifier, isTypeOnly);
     }
+    const importClause = tryParseImportClause(identifier, afterImportPos, isTypeOnly);
+    const moduleSpecifier = parseModuleSpecifier();
+    const attributes = tryParseImportAttributes();
+    parseSemicolon();
+    const node = factory2.createImportDeclaration(modifiers, importClause, moduleSpecifier, attributes);
+    return withJSDoc(finishNode(node, pos), hasJSDoc);
+  }
+  function tryParseImportClause(identifier, pos, isTypeOnly, skipJsDocLeadingAsterisks = false) {
     let importClause;
     if (identifier || // import id
     token() === 42 /* AsteriskToken */ || // import *
     token() === 19 /* OpenBraceToken */) {
-      importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
+      importClause = parseImportClause(identifier, pos, isTypeOnly, skipJsDocLeadingAsterisks);
       parseExpected(161 /* FromKeyword */);
     }
-    const moduleSpecifier = parseModuleSpecifier();
+    return importClause;
+  }
+  function tryParseImportAttributes() {
     const currentToken2 = token();
-    let attributes;
     if ((currentToken2 === 118 /* WithKeyword */ || currentToken2 === 132 /* AssertKeyword */) && !scanner2.hasPrecedingLineBreak()) {
-      attributes = parseImportAttributes(currentToken2);
+      return parseImportAttributes(currentToken2);
     }
-    parseSemicolon();
-    const node = factory2.createImportDeclaration(modifiers, importClause, moduleSpecifier, attributes);
-    return withJSDoc(finishNode(node, pos), hasJSDoc);
   }
   function parseImportAttribute() {
     const pos = getNodePos();
@@ -36276,10 +36396,14 @@ var Parser;
     const finished = withJSDoc(finishNode(node, pos), hasJSDoc);
     return finished;
   }
-  function parseImportClause(identifier, pos, isTypeOnly) {
+  function parseImportClause(identifier, pos, isTypeOnly, skipJsDocLeadingAsterisks) {
     let namedBindings;
     if (!identifier || parseOptional(28 /* CommaToken */)) {
+      if (skipJsDocLeadingAsterisks)
+        scanner2.setSkipJsDocLeadingAsterisks(true);
       namedBindings = token() === 42 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(275 /* NamedImports */);
+      if (skipJsDocLeadingAsterisks)
+        scanner2.setSkipJsDocLeadingAsterisks(false);
     }
     return finishNode(factory2.createImportClause(isTypeOnly, identifier, namedBindings), pos);
   }
@@ -36850,6 +36974,9 @@ var Parser;
           case "throws":
             tag = parseThrowsTag(start2, tagName, margin, indentText);
             break;
+          case "import":
+            tag = parseImportTag(start2, tagName, margin, indentText);
+            break;
           default:
             tag = parseUnknownTag(start2, tagName, margin, indentText);
             break;
@@ -37169,13 +37296,32 @@ var Parser;
         const comments2 = margin !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), margin, indentText) : void 0;
         return finishNode(factory2.createJSDocSatisfiesTag(tagName, typeExpression, comments2), start2);
       }
+      function parseImportTag(start2, tagName, margin, indentText) {
+        const afterImportTagPos = scanner2.getTokenFullStart();
+        let identifier;
+        if (isIdentifier2()) {
+          identifier = parseIdentifier();
+        }
+        const importClause = tryParseImportClause(
+          identifier,
+          afterImportTagPos,
+          /*isTypeOnly*/
+          true,
+          /*skipJsDocLeadingAsterisks*/
+          true
+        );
+        const moduleSpecifier = parseModuleSpecifier();
+        const attributes = tryParseImportAttributes();
+        const comments2 = margin !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start2, getNodePos(), margin, indentText) : void 0;
+        return finishNode(factory2.createJSDocImportTag(tagName, importClause, moduleSpecifier, attributes, comments2), start2);
+      }
       function parseExpressionWithTypeArgumentsForAugments() {
         const usedBrace = parseOptional(19 /* OpenBraceToken */);
         const pos = getNodePos();
         const expression = parsePropertyAccessEntityNameExpression();
-        scanner2.setInJSDocType(true);
+        scanner2.setSkipJsDocLeadingAsterisks(true);
         const typeArguments = tryParseTypeArguments();
-        scanner2.setInJSDocType(false);
+        scanner2.setSkipJsDocLeadingAsterisks(false);
         const node = factory2.createExpressionWithTypeArguments(expression, typeArguments);
         const res = finishNode(node, pos);
         if (usedBrace) {
@@ -44109,6 +44255,7 @@ function createBinder() {
   var lastContainer;
   var delayedTypeAliases;
   var seenThisKeyword;
+  var jsDocImports;
   var currentFlow;
   var currentBreakTarget;
   var currentContinueTarget;
@@ -44156,6 +44303,7 @@ function createBinder() {
       file.symbolCount = symbolCount;
       file.classifiableNames = classifiableNames;
       delayedBindJSDocTypedefTag();
+      bindJSDocImports();
     }
     file = void 0;
     options = void 0;
@@ -44166,6 +44314,7 @@ function createBinder() {
     blockScopeContainer = void 0;
     lastContainer = void 0;
     delayedTypeAliases = void 0;
+    jsDocImports = void 0;
     seenThisKeyword = false;
     currentFlow = void 0;
     currentBreakTarget = void 0;
@@ -44600,6 +44749,9 @@ function createBinder() {
       case 340 /* JSDocEnumTag */:
         bindJSDocTypeAlias(node);
         break;
+      case 351 /* JSDocImportTag */:
+        bindJSDocImportTag(node);
+        break;
       case 307 /* SourceFile */: {
         bindEachFunctionsFirst(node.statements);
         bind(node.endOfFileToken);
@@ -45332,6 +45484,12 @@ function createBinder() {
       addDeclarationToSymbol(host.symbol, host, 32 /* Class */);
     }
   }
+  function bindJSDocImportTag(node) {
+    bind(node.tagName);
+    if (typeof node.comment !== "string") {
+      bindEach(node.comment);
+    }
+  }
   function bindOptionalExpression(node, trueTarget, falseTarget) {
     doWithConditionalBranches(bind, node, trueTarget, falseTarget);
     if (!isOptionalChain(node) || isOutermostOptionalChain(node)) {
@@ -45648,6 +45806,31 @@ function createBinder() {
     parent2 = saveParent;
     currentFlow = saveCurrentFlow;
   }
+  function bindJSDocImports() {
+    if (jsDocImports === void 0) {
+      return;
+    }
+    const saveContainer = container;
+    const saveLastContainer = lastContainer;
+    const saveBlockScopeContainer = blockScopeContainer;
+    const saveParent = parent2;
+    const saveCurrentFlow = currentFlow;
+    for (const jsDocImportTag of jsDocImports) {
+      const host = getJSDocHost(jsDocImportTag);
+      const enclosingContainer = host ? getEnclosingContainer(host) : void 0;
+      const enclosingBlockScopeContainer = host ? getEnclosingBlockScopeContainer(host) : void 0;
+      container = enclosingContainer || file;
+      blockScopeContainer = enclosingBlockScopeContainer || file;
+      currentFlow = initFlowNode({ flags: 2 /* Start */ });
+      parent2 = jsDocImportTag;
+      bind(jsDocImportTag.importClause);
+    }
+    container = saveContainer;
+    lastContainer = saveLastContainer;
+    blockScopeContainer = saveBlockScopeContainer;
+    parent2 = saveParent;
+    currentFlow = saveCurrentFlow;
+  }
   function checkContextualIdentifier(node) {
     if (!file.parseDiagnostics.length && !(node.flags & 33554432 /* Ambient */) && !(node.flags & 16777216 /* JSDoc */) && !isIdentifierName(node)) {
       const originalKeywordKind = identifierToKeywordKind(node);
@@ -46072,6 +46255,8 @@ function createBinder() {
         return (delayedTypeAliases || (delayedTypeAliases = [])).push(node);
       case 339 /* JSDocOverloadTag */:
         return bind(node.typeExpression);
+      case 351 /* JSDocImportTag */:
+        return (jsDocImports || (jsDocImports = [])).push(node);
     }
   }
   function bindPropertyWorker(node) {
@@ -48036,6 +48221,10 @@ function createTypeChecker(host) {
   var checkBinaryExpression = createCheckBinaryExpression();
   var emitResolver = createResolver();
   var nodeBuilder = createNodeBuilder();
+  var evaluate = createEvaluator({
+    evaluateElementAccessExpression,
+    evaluateEntityNameExpression
+  });
   var globals = createSymbolTable();
   var undefinedSymbol = createSymbol(4 /* Property */, "undefined");
   undefinedSymbol.declarations = [];
@@ -49800,6 +49989,7 @@ function createTypeChecker(host) {
           case 346 /* JSDocTypedefTag */:
           case 338 /* JSDocCallbackTag */:
           case 340 /* JSDocEnumTag */:
+          case 351 /* JSDocImportTag */:
             const root = getJSDocRoot(location);
             if (root) {
               location = root.parent;
@@ -51292,7 +51482,7 @@ function createTypeChecker(host) {
       return ambientModule;
     }
     const currentSourceFile = getSourceFileOfNode(location);
-    const contextSpecifier = isStringLiteralLike(location) ? location : ((_a = isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : void 0) == null ? void 0 : _a.name) || ((_b = isLiteralImportTypeNode(location) ? location : void 0) == null ? void 0 : _b.argument.literal) || (isVariableDeclaration(location) && location.initializer && isRequireCall(
+    const contextSpecifier = isStringLiteralLike(location) ? location : ((_a = isModuleDeclaration(location) ? location : location.parent && isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : void 0) == null ? void 0 : _a.name) || ((_b = isLiteralImportTypeNode(location) ? location : void 0) == null ? void 0 : _b.argument.literal) || (isInJSFile(location) && isJSDocImportTag(location) ? location.moduleSpecifier : void 0) || (isVariableDeclaration(location) && location.initializer && isRequireCall(
       location.initializer,
       /*requireStringLiteralLikeArgument*/
       true
@@ -53205,7 +53395,7 @@ function createTypeChecker(host) {
         }
         const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
         if (some(abstractSignatures)) {
-          const types = map(abstractSignatures, getOrCreateTypeFromSignature);
+          const types = map(abstractSignatures, (s) => getOrCreateTypeFromSignature(s));
           const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
           // the logic in `createTypeNodesFromResolvedType`.
           (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
@@ -54520,7 +54710,7 @@ function createTypeChecker(host) {
           const type = getDeclaredTypeOfSymbol(sym);
           const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node);
           name.symbol = sym;
-          return { introducesError, node: setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
+          return { introducesError, node: setTextRange(setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */), node) };
         }
       }
       return { introducesError, node };
@@ -54530,7 +54720,6 @@ function createTypeChecker(host) {
         cancellationToken.throwIfCancellationRequested();
       }
       let hadError = false;
-      const file = getSourceFileOfNode(existing);
       const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
       if (hadError) {
         return void 0;
@@ -54681,8 +54870,17 @@ function createTypeChecker(host) {
             return result;
           }
         }
-        if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
-          setEmitFlags(node, 1 /* SingleLine */);
+        if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
+          const visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          const clone2 = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
+          const flags = getEmitFlags(clone2);
+          setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
+          return clone2;
         }
         return visitEachChild(
           node,
@@ -55668,19 +55866,20 @@ function createTypeChecker(host) {
           case 273 /* ImportClause */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
             const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
+            const attributes = isImportDeclaration(node.parent) ? node.parent.attributes : void 0;
+            const isTypeOnly = isJSDocImportTag(node.parent);
             addResult(
               factory.createImportDeclaration(
                 /*modifiers*/
                 void 0,
                 factory.createImportClause(
-                  /*isTypeOnly*/
-                  false,
+                  isTypeOnly,
                   factory.createIdentifier(localName),
                   /*namedBindings*/
                   void 0
                 ),
                 specifier2,
-                node.parent.attributes
+                attributes
               ),
               0 /* None */
             );
@@ -55689,13 +55888,13 @@ function createTypeChecker(host) {
           case 274 /* NamespaceImport */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
             const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
+            const isTypeOnly = isJSDocImportTag(node.parent.parent);
             addResult(
               factory.createImportDeclaration(
                 /*modifiers*/
                 void 0,
                 factory.createImportClause(
-                  /*isTypeOnly*/
-                  false,
+                  isTypeOnly,
                   /*name*/
                   void 0,
                   factory.createNamespaceImport(factory.createIdentifier(localName))
@@ -55723,13 +55922,13 @@ function createTypeChecker(host) {
           case 276 /* ImportSpecifier */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
             const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
+            const isTypeOnly = isJSDocImportTag(node.parent.parent.parent);
             addResult(
               factory.createImportDeclaration(
                 /*modifiers*/
                 void 0,
                 factory.createImportClause(
-                  /*isTypeOnly*/
-                  false,
+                  isTypeOnly,
                   /*name*/
                   void 0,
                   factory.createNamedImports([
@@ -58409,7 +58608,7 @@ function createTypeChecker(host) {
         if (!lateSymbol)
           lateSymbols.set(memberName, lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */));
         const earlySymbol = earlySymbols && earlySymbols.get(memberName);
-        if (!(parent2.flags & 32 /* Class */) && (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol)) {
+        if (!(parent2.flags & 32 /* Class */) && lateSymbol.flags & getExcludedSymbolFlags(symbolFlags)) {
           const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
           const name = !(type.flags & 8192 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
           forEach(declarations, (declaration) => error2(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
@@ -59361,11 +59560,15 @@ function createTypeChecker(host) {
     const modifiers = getMappedTypeModifiers(type);
     return modifiers & 8 /* ExcludeOptional */ ? -1 : modifiers & 4 /* IncludeOptional */ ? 1 : 0;
   }
-  function getModifiersTypeOptionality(type) {
-    return type.flags & 2097152 /* Intersection */ ? Math.max(...map(type.types, getModifiersTypeOptionality)) : getObjectFlags(type) & 32 /* Mapped */ ? getCombinedMappedTypeOptionality(type) : 0;
-  }
   function getCombinedMappedTypeOptionality(type) {
-    return getMappedTypeOptionality(type) || getModifiersTypeOptionality(getModifiersTypeFromMappedType(type));
+    if (getObjectFlags(type) & 32 /* Mapped */) {
+      return getMappedTypeOptionality(type) || getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(type));
+    }
+    if (type.flags & 2097152 /* Intersection */) {
+      const optionality = getCombinedMappedTypeOptionality(type.types[0]);
+      return every(type.types, (t, i) => i === 0 || getCombinedMappedTypeOptionality(t) === optionality) ? optionality : 0;
+    }
+    return 0;
   }
   function isPartialMappedType(type) {
     return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
@@ -60642,6 +60845,12 @@ function createTypeChecker(host) {
       isInJSFile(signature.declaration)
     );
   }
+  function getImplementationSignature(signature) {
+    return signature.typeParameters ? signature.implementationSignatureCache || (signature.implementationSignatureCache = createImplementationSignature(signature)) : signature;
+  }
+  function createImplementationSignature(signature) {
+    return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
+  }
   function getBaseSignature(signature) {
     const typeParameters = signature.typeParameters;
     if (typeParameters) {
@@ -60664,12 +60873,22 @@ function createTypeChecker(host) {
     }
     return signature;
   }
-  function getOrCreateTypeFromSignature(signature) {
+  function getOrCreateTypeFromSignature(signature, outerTypeParameters) {
     var _a;
     if (!signature.isolatedSignatureType) {
       const kind = (_a = signature.declaration) == null ? void 0 : _a.kind;
       const isConstructor = kind === void 0 || kind === 176 /* Constructor */ || kind === 180 /* ConstructSignature */ || kind === 185 /* ConstructorType */;
-      const type = createObjectType(16 /* Anonymous */);
+      const type = createObjectType(16 /* Anonymous */ | 134217728 /* SingleSignatureType */, createSymbol(16 /* Function */, "__function" /* Function */));
+      if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+        type.symbol.declarations = [signature.declaration];
+        type.symbol.valueDeclaration = signature.declaration;
+      }
+      outerTypeParameters || (outerTypeParameters = signature.declaration && getOuterTypeParameters(
+        signature.declaration,
+        /*includeThisTypes*/
+        true
+      ));
+      type.outerTypeParameters = outerTypeParameters;
       type.members = emptySymbols;
       type.properties = emptyArray;
       type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -63158,13 +63377,18 @@ function createTypeChecker(host) {
     const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
     const templateMapper = combineTypeMappers(objectType.mapper, mapper);
     const instantiatedTemplateType = instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
+    const isOptional = getMappedTypeOptionality(objectType) > 0 || (isGenericType(objectType) ? getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(objectType)) > 0 : couldAccessOptionalProperty(objectType, index));
     return addOptionality(
       instantiatedTemplateType,
       /*isProperty*/
       true,
-      getCombinedMappedTypeOptionality(objectType) > 0
+      isOptional
     );
   }
+  function couldAccessOptionalProperty(objectType, indexType) {
+    const indexConstraint = getBaseConstraintOfType(indexType);
+    return !!indexConstraint && some(getPropertiesOfType(objectType), (p) => !!(p.flags & 16777216 /* Optional */) && isTypeAssignableTo(getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */), indexConstraint));
+  }
   function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
     return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
   }
@@ -64075,7 +64299,7 @@ function createTypeChecker(host) {
     const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
     const links = getNodeLinks(declaration);
     const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
-    let typeParameters = links.outerTypeParameters;
+    let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
     if (!typeParameters) {
       let outerTypeParameters = getOuterTypeParameters(
         declaration,
@@ -64255,6 +64479,9 @@ function createTypeChecker(host) {
     if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
       result.node = type.node;
     }
+    if (type.objectFlags & 134217728 /* SingleSignatureType */) {
+      result.outerTypeParameters = type.outerTypeParameters;
+    }
     result.target = type;
     result.mapper = mapper;
     result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -68886,7 +69113,7 @@ function createTypeChecker(host) {
     if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
       return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
     }
-    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
     if (type.flags & 3899393 /* ObjectFlagsType */) {
       type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
     }
@@ -69170,6 +69397,9 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
+  function isTupleOfSelf(typeParameter, type) {
+    return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
+  }
   function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
@@ -69255,6 +69485,9 @@ function createTypeChecker(host) {
               inference.priority = priority;
             }
             if (priority === inference.priority) {
+              if (isTupleOfSelf(inference.typeParameter, candidate)) {
+                return;
+              }
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
@@ -69935,13 +70168,20 @@ function createTypeChecker(host) {
         return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
       case 166 /* QualifiedName */:
         const left = getFlowCacheKey(node.left, declaredType, initialType, flowContainer);
-        return left && left + "." + node.right.escapedText;
+        return left && `${left}.${node.right.escapedText}`;
       case 211 /* PropertyAccessExpression */:
       case 212 /* ElementAccessExpression */:
         const propName = getAccessedPropertyName(node);
         if (propName !== void 0) {
           const key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
-          return key && key + "." + propName;
+          return key && `${key}.${propName}`;
+        }
+        if (isElementAccessExpression(node) && isIdentifier(node.argumentExpression)) {
+          const symbol = getResolvedSymbol(node.argumentExpression);
+          if (isConstantVariable(symbol) || isParameterOrMutableLocalVariable(symbol) && !isSymbolAssigned(symbol)) {
+            const key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
+            return key && `${key}.@${getSymbolId(symbol)}`;
+          }
         }
         break;
       case 206 /* ObjectBindingPattern */:
@@ -69978,8 +70218,19 @@ function createTypeChecker(host) {
       case 211 /* PropertyAccessExpression */:
       case 212 /* ElementAccessExpression */:
         const sourcePropertyName = getAccessedPropertyName(source);
-        const targetPropertyName = isAccessExpression(target) ? getAccessedPropertyName(target) : void 0;
-        return sourcePropertyName !== void 0 && targetPropertyName !== void 0 && targetPropertyName === sourcePropertyName && isMatchingReference(source.expression, target.expression);
+        if (sourcePropertyName !== void 0) {
+          const targetPropertyName = isAccessExpression(target) ? getAccessedPropertyName(target) : void 0;
+          if (targetPropertyName !== void 0) {
+            return targetPropertyName === sourcePropertyName && isMatchingReference(source.expression, target.expression);
+          }
+        }
+        if (isElementAccessExpression(source) && isElementAccessExpression(target) && isIdentifier(source.argumentExpression) && isIdentifier(target.argumentExpression)) {
+          const symbol = getResolvedSymbol(source.argumentExpression);
+          if (symbol === getResolvedSymbol(target.argumentExpression) && (isConstantVariable(symbol) || isParameterOrMutableLocalVariable(symbol) && !isSymbolAssigned(symbol))) {
+            return isMatchingReference(source.expression, target.expression);
+          }
+        }
+        break;
       case 166 /* QualifiedName */:
         return isAccessExpression(target) && source.right.escapedText === getAccessedPropertyName(target) && isMatchingReference(source.left, target.expression);
       case 226 /* BinaryExpression */:
@@ -76175,7 +76426,7 @@ function createTypeChecker(host) {
     argument = skipParentheses(argument);
     return isSatisfiesExpression(argument) ? skipParentheses(argument.expression) : argument;
   }
-  function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain) {
+  function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
     const errorOutputContainer = { errors: void 0, skipLogging: true };
     if (isJsxOpeningLikeElement(node)) {
       if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
@@ -76209,7 +76460,8 @@ function createTypeChecker(host) {
           void 0,
           checkMode
         );
-        const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
+        const regularArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
+        const checkArgType = inferenceContext ? instantiateType(regularArgType, inferenceContext.nonFixingMapper) : regularArgType;
         const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
         if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? effectiveCheckArgumentNode : void 0, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
           Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -76621,7 +76873,9 @@ function createTypeChecker(host) {
             0 /* Normal */,
             /*reportErrors*/
             true,
-            () => chain
+            () => chain,
+            /*inferenceContext*/
+            void 0
           );
           if (diags) {
             for (const d of diags) {
@@ -76657,7 +76911,9 @@ function createTypeChecker(host) {
               0 /* Normal */,
               /*reportErrors*/
               true,
-              chain2
+              chain2,
+              /*inferenceContext*/
+              void 0
             );
             if (diags2) {
               if (diags2.length <= min2) {
@@ -76748,6 +77004,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           /*containingMessageChain*/
+          void 0,
+          /*inferenceContext*/
           void 0
         )) {
           candidatesForArgumentError = [candidate];
@@ -76756,13 +77014,16 @@ function createTypeChecker(host) {
         return candidate;
       }
       for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
-        const candidate = candidates2[candidateIndex];
+        let candidate = candidates2[candidateIndex];
         if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
           continue;
         }
         let checkCandidate;
         let inferenceContext;
         if (candidate.typeParameters) {
+          if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
+            candidate = getImplementationSignature(candidate);
+          }
           let typeArgumentTypes;
           if (some(typeArguments)) {
             typeArgumentTypes = checkTypeArguments(
@@ -76782,7 +77043,7 @@ function createTypeChecker(host) {
               /*flags*/
               isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
             );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
+            typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext), inferenceContext.nonFixingMapper);
             argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
           }
           checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -76802,7 +77063,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           /*containingMessageChain*/
-          void 0
+          void 0,
+          inferenceContext
         )) {
           (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
           continue;
@@ -76810,7 +77072,7 @@ function createTypeChecker(host) {
         if (argCheckMode) {
           argCheckMode = 0 /* Normal */;
           if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+            const typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext), inferenceContext.mapper);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
@@ -76826,7 +77088,8 @@ function createTypeChecker(host) {
             /*reportErrors*/
             false,
             /*containingMessageChain*/
-            void 0
+            void 0,
+            inferenceContext
           )) {
             (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
             continue;
@@ -80366,7 +80629,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node);
     return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
@@ -80580,7 +80843,7 @@ function createTypeChecker(host) {
                 }
               }
             }
-            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
+            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, (c) => c && map(c.inferences, (i) => i.typeParameter)).slice());
           }
         }
       }
@@ -80755,7 +81018,8 @@ function createTypeChecker(host) {
     if (getIsolatedModules(compilerOptions)) {
       Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
       const constEnumDeclaration = type.symbol.valueDeclaration;
-      if (constEnumDeclaration.flags & 33554432 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node)) {
+      const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(getSourceFileOfNode(constEnumDeclaration).resolvedPath);
+      if (constEnumDeclaration.flags & 33554432 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node) && (!redirect || !shouldPreserveConstEnums(redirect.commandLine.options))) {
         error2(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
       }
     }
@@ -82610,6 +82874,9 @@ function createTypeChecker(host) {
       error2(node.tagName, Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
     }
   }
+  function checkJSDocImportTag(node) {
+    checkImportAttributes(node);
+  }
   function checkJSDocImplementsTag(node) {
     const classLike = getEffectiveJSDocHost(node);
     if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
@@ -85339,122 +85606,53 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function evaluate(expr, location) {
-    switch (expr.kind) {
-      case 224 /* PrefixUnaryExpression */:
-        const value = evaluate(expr.operand, location);
-        if (typeof value === "number") {
-          switch (expr.operator) {
-            case 40 /* PlusToken */:
-              return value;
-            case 41 /* MinusToken */:
-              return -value;
-            case 55 /* TildeToken */:
-              return ~value;
-          }
-        }
-        break;
-      case 226 /* BinaryExpression */:
-        const left = evaluate(expr.left, location);
-        const right = evaluate(expr.right, location);
-        if (typeof left === "number" && typeof right === "number") {
-          switch (expr.operatorToken.kind) {
-            case 52 /* BarToken */:
-              return left | right;
-            case 51 /* AmpersandToken */:
-              return left & right;
-            case 49 /* GreaterThanGreaterThanToken */:
-              return left >> right;
-            case 50 /* GreaterThanGreaterThanGreaterThanToken */:
-              return left >>> right;
-            case 48 /* LessThanLessThanToken */:
-              return left << right;
-            case 53 /* CaretToken */:
-              return left ^ right;
-            case 42 /* AsteriskToken */:
-              return left * right;
-            case 44 /* SlashToken */:
-              return left / right;
-            case 40 /* PlusToken */:
-              return left + right;
-            case 41 /* MinusToken */:
-              return left - right;
-            case 45 /* PercentToken */:
-              return left % right;
-            case 43 /* AsteriskAsteriskToken */:
-              return left ** right;
-          }
-        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
-          return "" + left + right;
-        }
-        break;
-      case 11 /* StringLiteral */:
-      case 15 /* NoSubstitutionTemplateLiteral */:
-        return expr.text;
-      case 228 /* TemplateExpression */:
-        return evaluateTemplateExpression(expr, location);
-      case 9 /* NumericLiteral */:
-        checkGrammarNumericLiteral(expr);
-        return +expr.text;
-      case 217 /* ParenthesizedExpression */:
-        return evaluate(expr.expression, location);
-      case 80 /* Identifier */: {
-        const identifier = expr;
-        if (isInfinityOrNaNString(identifier.escapedText) && resolveEntityName(
-          identifier,
-          111551 /* Value */,
-          /*ignoreErrors*/
-          true
-        ) === getGlobalSymbol(
-          identifier.escapedText,
-          111551 /* Value */,
-          /*diagnostic*/
-          void 0
-        )) {
-          return +identifier.escapedText;
-        }
+  function evaluateEntityNameExpression(expr, location) {
+    const symbol = resolveEntityName(
+      expr,
+      111551 /* Value */,
+      /*ignoreErrors*/
+      true
+    );
+    if (!symbol)
+      return void 0;
+    if (expr.kind === 80 /* Identifier */) {
+      const identifier = expr;
+      if (isInfinityOrNaNString(identifier.escapedText) && symbol === getGlobalSymbol(
+        identifier.escapedText,
+        111551 /* Value */,
+        /*diagnostic*/
+        void 0
+      )) {
+        return +identifier.escapedText;
       }
-      case 211 /* PropertyAccessExpression */:
-        if (isEntityNameExpression(expr)) {
-          const symbol = resolveEntityName(
-            expr,
-            111551 /* Value */,
-            /*ignoreErrors*/
-            true
-          );
-          if (symbol) {
-            if (symbol.flags & 8 /* EnumMember */) {
-              return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
-            }
-            if (isConstantVariable(symbol)) {
-              const declaration = symbol.valueDeclaration;
-              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
-                return evaluate(declaration.initializer, declaration);
-              }
-            }
-          }
-        }
-        break;
-      case 212 /* ElementAccessExpression */:
-        const root = expr.expression;
-        if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
-          const rootSymbol = resolveEntityName(
-            root,
-            111551 /* Value */,
-            /*ignoreErrors*/
-            true
-          );
-          if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
-            const name = escapeLeadingUnderscores(expr.argumentExpression.text);
-            const member = rootSymbol.exports.get(name);
-            if (member) {
-              return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
-            }
-          }
+    }
+    if (symbol.flags & 8 /* EnumMember */) {
+      return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
+    }
+    if (isConstantVariable(symbol)) {
+      const declaration = symbol.valueDeclaration;
+      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
+        return evaluate(declaration.initializer, declaration);
+      }
+    }
+  }
+  function evaluateElementAccessExpression(expr, location) {
+    const root = expr.expression;
+    if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
+      const rootSymbol = resolveEntityName(
+        root,
+        111551 /* Value */,
+        /*ignoreErrors*/
+        true
+      );
+      if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
+        const name = escapeLeadingUnderscores(expr.argumentExpression.text);
+        const member = rootSymbol.exports.get(name);
+        if (member) {
+          return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
         }
-        break;
+      }
     }
-    return void 0;
   }
   function evaluateEnumMember(expr, symbol, location) {
     const declaration = symbol.valueDeclaration;
@@ -85468,18 +85666,6 @@ function createTypeChecker(host) {
     }
     return getEnumMemberValue(declaration);
   }
-  function evaluateTemplateExpression(expr, location) {
-    let result = expr.head.text;
-    for (const span of expr.templateSpans) {
-      const value = evaluate(span.expression, location);
-      if (value === void 0) {
-        return void 0;
-      }
-      result += value;
-      result += span.literal.text;
-    }
-    return result;
-  }
   function checkEnumDeclaration(node) {
     addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
   }
@@ -85877,7 +86063,8 @@ function createTypeChecker(host) {
         const message = isImportAttributes2 ? moduleKind === 199 /* NodeNext */ ? Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve : moduleKind === 199 /* NodeNext */ ? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve;
         return grammarErrorOnNode(node, message);
       }
-      if (isImportDeclaration(declaration) ? (_a = declaration.importClause) == null ? void 0 : _a.isTypeOnly : declaration.isTypeOnly) {
+      const isTypeOnly = isJSDocImportTag(declaration) || (isImportDeclaration(declaration) ? (_a = declaration.importClause) == null ? void 0 : _a.isTypeOnly : declaration.isTypeOnly);
+      if (isTypeOnly) {
         return grammarErrorOnNode(node, isImportAttributes2 ? Diagnostics.Import_attributes_cannot_be_used_with_type_only_imports_or_exports : Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports);
       }
       if (override) {
@@ -86328,6 +86515,8 @@ function createTypeChecker(host) {
         return checkJSDocSatisfiesTag(node);
       case 343 /* JSDocThisTag */:
         return checkJSDocThisTag(node);
+      case 351 /* JSDocImportTag */:
+        return checkJSDocImportTag(node);
       case 199 /* IndexedAccessType */:
         return checkIndexedAccessType(node);
       case 200 /* MappedType */:
@@ -87131,7 +87320,7 @@ function createTypeChecker(host) {
         return void 0;
       case 11 /* StringLiteral */:
       case 15 /* NoSubstitutionTemplateLiteral */:
-        if (isExternalModuleImportEqualsDeclaration(node.parent.parent) && getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node || (node.parent.kind === 272 /* ImportDeclaration */ || node.parent.kind === 278 /* ExportDeclaration */) && node.parent.moduleSpecifier === node || (isInJSFile(node) && isRequireCall(
+        if (isExternalModuleImportEqualsDeclaration(node.parent.parent) && getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node || (node.parent.kind === 272 /* ImportDeclaration */ || node.parent.kind === 278 /* ExportDeclaration */) && node.parent.moduleSpecifier === node || isInJSFile(node) && isJSDocImportTag(node.parent) && node.parent.moduleSpecifier === node || (isInJSFile(node) && isRequireCall(
           node.parent,
           /*requireStringLiteralLikeArgument*/
           false
@@ -91272,13 +91461,13 @@ var visitEachChildTable = {
     );
   },
   // Transformation nodes
-  [353 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+  [354 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
     return context.factory.updatePartiallyEmittedExpression(
       node,
       Debug.checkDefined(nodeVisitor(node.expression, visitor, isExpression))
     );
   },
-  [354 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+  [355 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
     return context.factory.updateCommaListExpression(
       node,
       nodesVisitor(node.elements, visitor, isExpression)
@@ -95122,7 +95311,7 @@ function transformClassFields(context) {
           /*discarded*/
           true
         );
-      case 354 /* CommaListExpression */:
+      case 355 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -98215,7 +98404,7 @@ function transformESDecorators(context) {
         return visitForStatement(node);
       case 244 /* ExpressionStatement */:
         return visitExpressionStatement(node);
-      case 354 /* CommaListExpression */:
+      case 355 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -98227,7 +98416,7 @@ function transformESDecorators(context) {
           /*discarded*/
           false
         );
-      case 353 /* PartiallyEmittedExpression */:
+      case 354 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(
           node,
           /*discarded*/
@@ -98313,7 +98502,7 @@ function transformESDecorators(context) {
           /*discarded*/
           true
         );
-      case 354 /* CommaListExpression */:
+      case 355 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -100904,7 +101093,7 @@ function transformES2018(context) {
         return visitObjectLiteralExpression(node);
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node, expressionResultIsUnused2);
-      case 354 /* CommaListExpression */:
+      case 355 /* CommaListExpression */:
         return visitCommaListExpression(node, expressionResultIsUnused2);
       case 299 /* CatchClause */:
         return visitCatchClause(node);
@@ -104127,7 +104316,7 @@ function transformES2015(context) {
         return visitParenthesizedExpression(node, expressionResultIsUnused2);
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node, expressionResultIsUnused2);
-      case 354 /* CommaListExpression */:
+      case 355 /* CommaListExpression */:
         return visitCommaListExpression(node, expressionResultIsUnused2);
       case 15 /* NoSubstitutionTemplateLiteral */:
       case 16 /* TemplateHead */:
@@ -107422,7 +107611,7 @@ function transformGenerators(context) {
     switch (node.kind) {
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node);
-      case 354 /* CommaListExpression */:
+      case 355 /* CommaListExpression */:
         return visitCommaListExpression(node);
       case 227 /* ConditionalExpression */:
         return visitConditionalExpression(node);
@@ -109812,7 +110001,7 @@ function transformModule(context) {
         return visitExpressionStatement(node);
       case 217 /* ParenthesizedExpression */:
         return visitParenthesizedExpression(node, valueIsDiscarded);
-      case 353 /* PartiallyEmittedExpression */:
+      case 354 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 213 /* CallExpression */:
         if (isImportCall(node) && currentSourceFile.impliedNodeFormat === void 0) {
@@ -112205,7 +112394,7 @@ function transformSystemModule(context) {
         return visitExpressionStatement(node);
       case 217 /* ParenthesizedExpression */:
         return visitParenthesizedExpression(node, valueIsDiscarded);
-      case 353 /* PartiallyEmittedExpression */:
+      case 354 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 226 /* BinaryExpression */:
         if (isDestructuringAssignment(node)) {
@@ -114218,6 +114407,8 @@ function transformDeclarations(context) {
     }
     if (isDeclaration(input) && isDeclarationAndNotVisible(input))
       return;
+    if (isJSDocImportTag(input))
+      return;
     if (isFunctionLike(input) && resolver.isImplementationOfOverload(input))
       return;
     let previousEnclosingDeclaration;
@@ -114865,7 +115056,7 @@ function noEmitNotification(hint, node, callback) {
 }
 function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) {
   var _a, _b;
-  const enabledSyntaxKindFeatures = new Array(356 /* Count */);
+  const enabledSyntaxKindFeatures = new Array(357 /* Count */);
   let lexicalEnvironmentVariableDeclarations;
   let lexicalEnvironmentFunctionDeclarations;
   let lexicalEnvironmentStatements;
@@ -116444,7 +116635,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJSDocTypedefTag(node);
         case 347 /* JSDocSeeTag */:
           return emitJSDocSeeTag(node);
-        case 352 /* NotEmittedStatement */:
+        case 351 /* JSDocImportTag */:
+          return emitJSDocImportTag(node);
+        case 353 /* NotEmittedStatement */:
           return;
       }
       if (isExpression(node)) {
@@ -116545,15 +116738,15 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJsxSelfClosingElement(node);
         case 288 /* JsxFragment */:
           return emitJsxFragment(node);
-        case 351 /* SyntaxList */:
+        case 352 /* SyntaxList */:
           return Debug.fail("SyntaxList should not be printed");
-        case 352 /* NotEmittedStatement */:
+        case 353 /* NotEmittedStatement */:
           return;
-        case 353 /* PartiallyEmittedExpression */:
+        case 354 /* PartiallyEmittedExpression */:
           return emitPartiallyEmittedExpression(node);
-        case 354 /* CommaListExpression */:
+        case 355 /* CommaListExpression */:
           return emitCommaList(node);
-        case 355 /* SyntheticReferenceExpression */:
+        case 356 /* SyntheticReferenceExpression */:
           return Debug.fail("SyntheticReferenceExpression should not be printed");
       }
     }
@@ -118397,6 +118590,21 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     emit(tag.name);
     emitJSDocComment(tag.comment);
   }
+  function emitJSDocImportTag(tag) {
+    emitJSDocTagName(tag.tagName);
+    writeSpace();
+    if (tag.importClause) {
+      emit(tag.importClause);
+      writeSpace();
+      emitTokenWithComment(161 /* FromKeyword */, tag.importClause.end, writeKeyword, tag);
+      writeSpace();
+    }
+    emitExpression(tag.moduleSpecifier);
+    if (tag.attributes) {
+      emitWithLeadingSpace(tag.attributes);
+    }
+    emitJSDocComment(tag.comment);
+  }
   function emitJSDocNameReference(node) {
     writeSpace();
     writePunctuation("{");
@@ -119809,7 +120017,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         emitLeadingComments(
           pos,
           /*isEmittedNode*/
-          node.kind !== 352 /* NotEmittedStatement */
+          node.kind !== 353 /* NotEmittedStatement */
         );
       }
       if (!skipLeadingComments || pos >= 0 && (emitFlags & 1024 /* NoLeadingComments */) !== 0) {
@@ -119833,7 +120041,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       containerPos = savedContainerPos;
       containerEnd = savedContainerEnd;
       declarationListContainerEnd = savedDeclarationListContainerEnd;
-      if (!skipTrailingComments && node.kind !== 352 /* NotEmittedStatement */) {
+      if (!skipTrailingComments && node.kind !== 353 /* NotEmittedStatement */) {
         emitTrailingComments(end);
       }
     }
@@ -120085,7 +120293,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     const emitFlags = getEmitFlags(node);
     const sourceMapRange = getSourceMapRange(node);
     const source = sourceMapRange.source || sourceMapSource;
-    if (node.kind !== 352 /* NotEmittedStatement */ && (emitFlags & 32 /* NoLeadingSourceMap */) === 0 && sourceMapRange.pos >= 0) {
+    if (node.kind !== 353 /* NotEmittedStatement */ && (emitFlags & 32 /* NoLeadingSourceMap */) === 0 && sourceMapRange.pos >= 0) {
       emitSourcePos(sourceMapRange.source || sourceMapSource, skipSourceTrivia(source, sourceMapRange.pos));
     }
     if (emitFlags & 128 /* NoNestedSourceMaps */) {
@@ -120098,7 +120306,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     if (emitFlags & 128 /* NoNestedSourceMaps */) {
       sourceMapsDisabled = false;
     }
-    if (node.kind !== 352 /* NotEmittedStatement */ && (emitFlags & 64 /* NoTrailingSourceMap */) === 0 && sourceMapRange.end >= 0) {
+    if (node.kind !== 353 /* NotEmittedStatement */ && (emitFlags & 64 /* NoTrailingSourceMap */) === 0 && sourceMapRange.end >= 0) {
       emitSourcePos(sourceMapRange.source || sourceMapSource, sourceMapRange.end);
     }
   }
@@ -121880,6 +122088,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     getResolvedProjectReferenceByPath,
     forEachResolvedProjectReference: forEachResolvedProjectReference2,
     isSourceOfProjectReferenceRedirect,
+    getRedirectReferenceForResolutionFromSourceOfProject,
     emitBuildInfo,
     fileExists,
     readFile,
@@ -123022,7 +123231,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       );
     }
     if (file.flags & 4194304 /* PossiblyContainsDynamicImport */ || isJavaScriptFile) {
-      collectDynamicImportOrRequireCalls(file);
+      collectDynamicImportOrRequireOrJsDocImportCalls(file);
     }
     file.imports = imports || emptyArray;
     file.moduleAugmentations = moduleAugmentations || emptyArray;
@@ -123066,7 +123275,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         }
       }
     }
-    function collectDynamicImportOrRequireCalls(file2) {
+    function collectDynamicImportOrRequireOrJsDocImportCalls(file2) {
       const r = /import|require/g;
       while (r.exec(file2.text) !== null) {
         const node = getNodeAtPosition(file2, r.lastIndex);
@@ -123095,6 +123304,16 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
             false
           );
           imports = append(imports, node.argument.literal);
+        } else if (isJavaScriptFile && isJSDocImportTag(node)) {
+          const moduleNameExpr = getExternalModuleName(node);
+          if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text) {
+            setParentRecursive(
+              node,
+              /*incremental*/
+              false
+            );
+            imports = append(imports, moduleNameExpr);
+          }
         }
       }
     }
@@ -132982,7 +133201,7 @@ function symbolEscapedNameNoDefault(symbol) {
   });
 }
 function isModuleSpecifierLike(node) {
-  return isStringLiteralLike(node) && (isExternalModuleReference(node.parent) || isImportDeclaration(node.parent) || isRequireCall(
+  return isStringLiteralLike(node) && (isExternalModuleReference(node.parent) || isImportDeclaration(node.parent) || isJSDocImportTag(node.parent) || isRequireCall(
     node.parent,
     /*requireStringLiteralLikeArgument*/
     false
@@ -136359,14 +136578,14 @@ function getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, so
     return newFileName && { newFileName, updated: true };
   }
 }
-function updateImportsWorker(sourceFile, changeTracker, updateRef, updateImport2) {
+function updateImportsWorker(sourceFile, changeTracker, updateRef, updateImport) {
   for (const ref of sourceFile.referencedFiles || emptyArray) {
     const updated = updateRef(ref.fileName);
     if (updated !== void 0 && updated !== sourceFile.text.slice(ref.pos, ref.end))
       changeTracker.replaceRangeWithText(sourceFile, ref, updated);
   }
   for (const importStringLiteral of sourceFile.imports) {
-    const updated = updateImport2(importStringLiteral);
+    const updated = updateImport(importStringLiteral);
     if (updated !== void 0 && updated !== importStringLiteral.text)
       changeTracker.replaceRangeWithText(sourceFile, createStringRange(importStringLiteral, sourceFile), updated);
   }
@@ -138790,8 +139009,8 @@ function getImportConversionInfo(context, considerPartialSpans = true) {
   const { file } = context;
   const span = getRefactorContextSpan(context);
   const token = getTokenAtPosition(file, span.start);
-  const importDecl = considerPartialSpans ? findAncestor(token, isImportDeclaration) : getParentNodeInSpan(token, file, span);
-  if (!importDecl || !isImportDeclaration(importDecl))
+  const importDecl = considerPartialSpans ? findAncestor(token, or(isImportDeclaration, isJSDocImportTag)) : getParentNodeInSpan(token, file, span);
+  if (importDecl === void 0 || !(isImportDeclaration(importDecl) || isJSDocImportTag(importDecl)))
     return { error: "Selection is not an import declaration." };
   const end = span.start + span.length;
   const nextToken = findNextToken(importDecl, importDecl.parent, file);
@@ -138862,15 +139081,16 @@ function doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert, allow
     ));
   });
   const importDecl = toConvert.parent.parent;
-  if (usedAsNamespaceOrDefault && !allowSyntheticDefaultImports) {
-    changes.insertNodeAfter(sourceFile, importDecl, updateImport(
+  if (usedAsNamespaceOrDefault && !allowSyntheticDefaultImports && isImportDeclaration(importDecl)) {
+    changes.insertNodeAfter(sourceFile, importDecl, createImport(
       importDecl,
       /*defaultImportName*/
       void 0,
       importSpecifiers
     ));
   } else {
-    changes.replaceNode(sourceFile, importDecl, updateImport(importDecl, usedAsNamespaceOrDefault ? factory.createIdentifier(toConvert.name.text) : void 0, importSpecifiers));
+    const defaultImportName = usedAsNamespaceOrDefault ? factory.createIdentifier(toConvert.name.text) : void 0;
+    changes.replaceNode(sourceFile, toConvert.parent, createImportClause(defaultImportName, importSpecifiers));
   }
 }
 function getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) {
@@ -138930,9 +139150,9 @@ function doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, toConve
     toConvert,
     shouldUseDefault ? factory.createIdentifier(namespaceImportName) : factory.createNamespaceImport(factory.createIdentifier(namespaceImportName))
   );
-  if (neededNamedImports.size) {
+  if (neededNamedImports.size && isImportDeclaration(importDecl)) {
     const newNamedImports = arrayFrom(neededNamedImports.values(), (element) => factory.createImportSpecifier(element.isTypeOnly, element.propertyName && factory.createIdentifier(element.propertyName.text), factory.createIdentifier(element.name.text)));
-    changes.insertNodeAfter(sourceFile, toConvert.parent.parent, updateImport(
+    changes.insertNodeAfter(sourceFile, toConvert.parent.parent, createImport(
       importDecl,
       /*defaultImportName*/
       void 0,
@@ -138947,21 +139167,24 @@ function isExportEqualsModule(moduleSpecifier, checker) {
   const exportEquals = checker.resolveExternalModuleSymbol(externalModule);
   return externalModule !== exportEquals;
 }
-function updateImport(old, defaultImportName, elements) {
+function createImport(node, defaultImportName, elements) {
   return factory.createImportDeclaration(
     /*modifiers*/
     void 0,
-    factory.createImportClause(
-      /*isTypeOnly*/
-      false,
-      defaultImportName,
-      elements && elements.length ? factory.createNamedImports(elements) : void 0
-    ),
-    old.moduleSpecifier,
+    createImportClause(defaultImportName, elements),
+    node.moduleSpecifier,
     /*attributes*/
     void 0
   );
 }
+function createImportClause(defaultImportName, elements) {
+  return factory.createImportClause(
+    /*isTypeOnly*/
+    false,
+    defaultImportName,
+    elements && elements.length ? factory.createNamedImports(elements) : void 0
+  );
+}
 
 // src/services/refactors/extractType.ts
 var refactorName3 = "Extract type";
@@ -144184,7 +144407,7 @@ var NodeObject = class {
     if (!children.length) {
       return void 0;
     }
-    const child = find(children, (kid) => kid.kind < 309 /* FirstJSDocNode */ || kid.kind > 350 /* LastJSDocNode */);
+    const child = find(children, (kid) => kid.kind < 309 /* FirstJSDocNode */ || kid.kind > 351 /* LastJSDocNode */);
     return child.kind < 166 /* FirstNode */ ? child : child.getFirstToken(sourceFile);
   }
   getLastToken(sourceFile) {
@@ -144251,7 +144474,7 @@ function addSyntheticNodes(nodes, pos, end, parent2) {
   }
 }
 function createSyntaxList(nodes, parent2) {
-  const list = createNode(351 /* SyntaxList */, nodes.pos, nodes.end, parent2);
+  const list = createNode(352 /* SyntaxList */, nodes.pos, nodes.end, parent2);
   list._children = [];
   let pos = nodes.pos;
   for (const node of nodes) {
@@ -149856,7 +150079,7 @@ registerCodeFix({
     const declaration = getDeclaration2(context.sourceFile, context.span.start);
     if (declaration) {
       const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, context.sourceFile, declaration));
-      const importDeclarationChanges = declaration.kind === 276 /* ImportSpecifier */ && canConvertImportDeclarationForSpecifier(declaration, context.sourceFile, context.program) ? ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, context.sourceFile, declaration.parent.parent.parent)) : void 0;
+      const importDeclarationChanges = declaration.kind === 276 /* ImportSpecifier */ && isImportDeclaration(declaration.parent.parent.parent) && canConvertImportDeclarationForSpecifier(declaration, context.sourceFile, context.program) ? ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, context.sourceFile, declaration.parent.parent.parent)) : void 0;
       const mainAction = createCodeFixAction(
         fixId13,
         changes,
@@ -149882,7 +150105,7 @@ registerCodeFix({
       if ((errorDeclaration == null ? void 0 : errorDeclaration.kind) === 272 /* ImportDeclaration */ && !fixedImportDeclarations.has(errorDeclaration)) {
         doChange11(changes, diag2.file, errorDeclaration);
         fixedImportDeclarations.add(errorDeclaration);
-      } else if ((errorDeclaration == null ? void 0 : errorDeclaration.kind) === 276 /* ImportSpecifier */ && !fixedImportDeclarations.has(errorDeclaration.parent.parent.parent) && canConvertImportDeclarationForSpecifier(errorDeclaration, diag2.file, context.program)) {
+      } else if ((errorDeclaration == null ? void 0 : errorDeclaration.kind) === 276 /* ImportSpecifier */ && isImportDeclaration(errorDeclaration.parent.parent.parent) && !fixedImportDeclarations.has(errorDeclaration.parent.parent.parent) && canConvertImportDeclarationForSpecifier(errorDeclaration, diag2.file, context.program)) {
         doChange11(changes, diag2.file, errorDeclaration.parent.parent.parent);
         fixedImportDeclarations.add(errorDeclaration.parent.parent.parent);
       } else if ((errorDeclaration == null ? void 0 : errorDeclaration.kind) === 276 /* ImportSpecifier */) {
@@ -150754,6 +150977,7 @@ function getNamespaceLikeImportText(declaration) {
       return (_a = tryCast(declaration.name, isIdentifier)) == null ? void 0 : _a.text;
     case 271 /* ImportEqualsDeclaration */:
       return declaration.name.text;
+    case 351 /* JSDocImportTag */:
     case 272 /* ImportDeclaration */:
       return (_c = tryCast((_b = declaration.importClause) == null ? void 0 : _b.namedBindings, isNamespaceImport)) == null ? void 0 : _c.name.text;
     default:
@@ -150831,7 +151055,7 @@ function createExistingImportMap(checker, importingFile, compilerOptions) {
       if (moduleSymbol) {
         (importMap || (importMap = createMultiMap())).add(getSymbolId(moduleSymbol), i.parent);
       }
-    } else if (i.kind === 272 /* ImportDeclaration */ || i.kind === 271 /* ImportEqualsDeclaration */) {
+    } else if (i.kind === 272 /* ImportDeclaration */ || i.kind === 271 /* ImportEqualsDeclaration */ || i.kind === 351 /* JSDocImportTag */) {
       const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
       if (moduleSymbol) {
         (importMap || (importMap = createMultiMap())).add(getSymbolId(moduleSymbol), i);
@@ -150840,11 +151064,11 @@ function createExistingImportMap(checker, importingFile, compilerOptions) {
   }
   return {
     getImportsForExportInfo: ({ moduleSymbol, exportKind, targetFlags, symbol }) => {
-      if (!(targetFlags & 111551 /* Value */) && isSourceFileJS(importingFile))
-        return emptyArray;
       const matchingDeclarations = importMap == null ? void 0 : importMap.get(getSymbolId(moduleSymbol));
       if (!matchingDeclarations)
         return emptyArray;
+      if (isSourceFileJS(importingFile) && !(targetFlags & 111551 /* Value */) && !every(matchingDeclarations, isJSDocImportTag))
+        return emptyArray;
       const importKind = getImportKind(importingFile, exportKind, compilerOptions);
       return matchingDeclarations.map((declaration) => ({ declaration, importKind, symbol, targetFlags }));
     }
@@ -157104,7 +157328,7 @@ function getInfo19(sourceFile, pos) {
   const { parent: parent2 } = name;
   if (isImportEqualsDeclaration(parent2) && isExternalModuleReference(parent2.moduleReference)) {
     return { importNode: parent2, name, moduleSpecifier: parent2.moduleReference.expression };
-  } else if (isNamespaceImport(parent2)) {
+  } else if (isNamespaceImport(parent2) && isImportDeclaration(parent2.parent.parent)) {
     const importNode = parent2.parent.parent;
     return { importNode, name, moduleSpecifier: importNode.moduleSpecifier };
   }
@@ -159273,7 +159497,8 @@ function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, con
   }
   function symbolAppearsToBeTypeOnly(symbol) {
     var _a;
-    return !(symbol.flags & 111551 /* Value */) && (!isInJSFile((_a = symbol.declarations) == null ? void 0 : _a[0]) || !!(symbol.flags & 788968 /* Type */));
+    const flags = getCombinedLocalAndExportSymbolFlags(skipAlias(symbol, typeChecker));
+    return !(flags & 111551 /* Value */) && (!isInJSFile((_a = symbol.declarations) == null ? void 0 : _a[0]) || !!(flags & 788968 /* Type */));
   }
 }
 function getLabelCompletionAtPosition(node) {
@@ -159614,6 +159839,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   const insideComment = isInComment(sourceFile, position, currentToken);
   log("getCompletionData: Is inside comment: " + (timestamp() - start));
   let insideJsDocTagTypeExpression = false;
+  let insideJsDocImportTag = false;
   let isInSnippetScope = false;
   if (insideComment) {
     if (hasDocComment(sourceFile, position)) {
@@ -159631,24 +159857,28 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       if (tag.tagName.pos <= position && position <= tag.tagName.end) {
         return { kind: 1 /* JsDocTagName */ };
       }
-      const typeExpression = tryGetTypeExpressionFromTag(tag);
-      if (typeExpression) {
-        currentToken = getTokenAtPosition(sourceFile, position);
-        if (!currentToken || !isDeclarationName(currentToken) && (currentToken.parent.kind !== 348 /* JSDocPropertyTag */ || currentToken.parent.name !== currentToken)) {
-          insideJsDocTagTypeExpression = isCurrentlyEditingNode(typeExpression);
+      if (isJSDocImportTag(tag)) {
+        insideJsDocImportTag = true;
+      } else {
+        const typeExpression = tryGetTypeExpressionFromTag(tag);
+        if (typeExpression) {
+          currentToken = getTokenAtPosition(sourceFile, position);
+          if (!currentToken || !isDeclarationName(currentToken) && (currentToken.parent.kind !== 348 /* JSDocPropertyTag */ || currentToken.parent.name !== currentToken)) {
+            insideJsDocTagTypeExpression = isCurrentlyEditingNode(typeExpression);
+          }
+        }
+        if (!insideJsDocTagTypeExpression && isJSDocParameterTag(tag) && (nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {
+          return { kind: 3 /* JsDocParameterName */, tag };
         }
-      }
-      if (!insideJsDocTagTypeExpression && isJSDocParameterTag(tag) && (nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {
-        return { kind: 3 /* JsDocParameterName */, tag };
       }
     }
-    if (!insideJsDocTagTypeExpression) {
+    if (!insideJsDocTagTypeExpression && !insideJsDocImportTag) {
       log("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment.");
       return void 0;
     }
   }
   start = timestamp();
-  const isJsOnlyLocation = !insideJsDocTagTypeExpression && isSourceFileJS(sourceFile);
+  const isJsOnlyLocation = !insideJsDocTagTypeExpression && !insideJsDocImportTag && isSourceFileJS(sourceFile);
   const tokens = getRelevantTokens(position, sourceFile);
   const previousToken = tokens.previousToken;
   let contextToken = tokens.contextToken;
@@ -160161,7 +160391,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     }
   }
   function isTypeOnlyCompletion() {
-    return insideJsDocTagTypeExpression || !!importStatementCompletion && isTypeOnlyImportOrExportDeclaration(location.parent) || !isContextTokenValueLocation(contextToken) && (isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker) || isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken));
+    return insideJsDocTagTypeExpression || insideJsDocImportTag || !!importStatementCompletion && isTypeOnlyImportOrExportDeclaration(location.parent) || !isContextTokenValueLocation(contextToken) && (isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker) || isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken));
   }
   function isContextTokenValueLocation(contextToken2) {
     return contextToken2 && (contextToken2.kind === 114 /* TypeOfKeyword */ && (contextToken2.parent.kind === 186 /* TypeQuery */ || isTypeOfExpression(contextToken2.parent)) || contextToken2.kind === 131 /* AssertsKeyword */ && contextToken2.parent.kind === 182 /* TypePredicate */);
@@ -161185,7 +161415,7 @@ function getPropertiesForCompletion(type, checker) {
 }
 function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location, position) {
   switch (location.kind) {
-    case 351 /* SyntaxList */:
+    case 352 /* SyntaxList */:
       return tryCast(location.parent, isObjectTypeDeclaration);
     case 1 /* EndOfFileToken */:
       const cls = tryCast(lastOrUndefined(cast(location.parent, isSourceFile).statements), isObjectTypeDeclaration);
@@ -161416,13 +161646,13 @@ function getSingleLineReplacementSpanForImportCompletionNode(node) {
   var _a;
   if (!node)
     return void 0;
-  const top = findAncestor(node, or(isImportDeclaration, isImportEqualsDeclaration)) ?? node;
+  const top = findAncestor(node, or(isImportDeclaration, isImportEqualsDeclaration, isJSDocImportTag)) ?? node;
   const sourceFile = top.getSourceFile();
   if (rangeIsOnSingleLine(top, sourceFile)) {
     return createTextSpanFromNode(top, sourceFile);
   }
   Debug.assert(top.kind !== 102 /* ImportKeyword */ && top.kind !== 276 /* ImportSpecifier */);
-  const potentialSplitPoint = top.kind === 272 /* ImportDeclaration */ ? getPotentiallyInvalidImportSpecifier((_a = top.importClause) == null ? void 0 : _a.namedBindings) ?? top.moduleSpecifier : top.moduleReference;
+  const potentialSplitPoint = top.kind === 272 /* ImportDeclaration */ || top.kind === 351 /* JSDocImportTag */ ? getPotentiallyInvalidImportSpecifier((_a = top.importClause) == null ? void 0 : _a.namedBindings) ?? top.moduleSpecifier : top.moduleReference;
   const withoutModuleSpecifier = {
     pos: top.getFirstToken().getStart(),
     end: potentialSplitPoint.pos
@@ -161718,6 +161948,7 @@ function getStringLiteralCompletionEntries(sourceFile, node, position, program,
     case 272 /* ImportDeclaration */:
     case 278 /* ExportDeclaration */:
     case 283 /* ExternalModuleReference */:
+    case 351 /* JSDocImportTag */:
       return { kind: 0 /* Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, program, host, preferences) };
     case 296 /* CaseClause */:
       const tracker = newCaseClauseTracker(typeChecker, parent2.parent.clauses);
@@ -162514,6 +162745,7 @@ function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, {
             );
             break;
           case 272 /* ImportDeclaration */:
+          case 351 /* JSDocImportTag */:
             directImports.push(direct);
             const namedBindings = direct.importClause && direct.importClause.namedBindings;
             if (namedBindings && namedBindings.kind === 274 /* NamespaceImport */) {
@@ -166247,6 +166479,7 @@ var jsDocTagNames = [
   "host",
   "ignore",
   "implements",
+  "import",
   "inheritdoc",
   "inner",
   "instance",
@@ -173685,6 +173918,7 @@ __export(ts_exports2, {
   createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
   createEmitHelperFactory: () => createEmitHelperFactory,
   createEmptyExports: () => createEmptyExports,
+  createEvaluator: () => createEvaluator,
   createExpressionForJsxElement: () => createExpressionForJsxElement,
   createExpressionForJsxFragment: () => createExpressionForJsxFragment,
   createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
@@ -174749,6 +174983,7 @@ __export(ts_exports2, {
   isJSDocEnumTag: () => isJSDocEnumTag,
   isJSDocFunctionType: () => isJSDocFunctionType,
   isJSDocImplementsTag: () => isJSDocImplementsTag,
+  isJSDocImportTag: () => isJSDocImportTag,
   isJSDocIndexSignature: () => isJSDocIndexSignature,
   isJSDocLikeText: () => isJSDocLikeText,
   isJSDocLink: () => isJSDocLink,
@@ -179902,7 +180137,16 @@ function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) {
       recursive ? watchedDirectoriesRecursive : watchedDirectories,
       path,
       callback,
-      (id) => ({ eventName: CreateDirectoryWatcherEvent, data: { id, path, recursive: !!recursive } })
+      (id) => ({
+        eventName: CreateDirectoryWatcherEvent,
+        data: {
+          id,
+          path,
+          recursive: !!recursive,
+          // Special case node_modules as we watch it for changes to closed script infos as well
+          ignoreUpdate: !path.endsWith("/node_modules") ? true : void 0
+        }
+      })
     );
   }
   function getOrCreateFileWatcher({ pathToId, idToCallbacks }, path, callback, event) {
@@ -179929,24 +180173,28 @@ function createWatchFactoryHostUsingWatchEvents(service, canUseWatchEvents) {
       }
     };
   }
-  function onWatchChange({ id, path, eventType }) {
-    onFileWatcherCallback(id, path, eventType);
-    onDirectoryWatcherCallback(watchedDirectories, id, path, eventType);
-    onDirectoryWatcherCallback(watchedDirectoriesRecursive, id, path, eventType);
+  function onWatchChange(args) {
+    if (isArray(args))
+      args.forEach(onWatchChangeRequestArgs);
+    else
+      onWatchChangeRequestArgs(args);
+  }
+  function onWatchChangeRequestArgs({ id, created, deleted, updated }) {
+    onWatchEventType(id, created, 0 /* Created */);
+    onWatchEventType(id, deleted, 2 /* Deleted */);
+    onWatchEventType(id, updated, 1 /* Changed */);
   }
-  function onFileWatcherCallback(id, eventPath, eventType) {
-    var _a;
-    (_a = watchedFiles.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-      const eventKind = eventType === "create" ? 0 /* Created */ : eventType === "delete" ? 2 /* Deleted */ : 1 /* Changed */;
-      callback(eventPath, eventKind);
-    });
+  function onWatchEventType(id, paths, eventKind) {
+    if (!(paths == null ? void 0 : paths.length))
+      return;
+    forEachCallback(watchedFiles, id, paths, (callback, eventPath) => callback(eventPath, eventKind));
+    forEachCallback(watchedDirectories, id, paths, (callback, eventPath) => callback(eventPath));
+    forEachCallback(watchedDirectoriesRecursive, id, paths, (callback, eventPath) => callback(eventPath));
   }
-  function onDirectoryWatcherCallback({ idToCallbacks }, id, eventPath, eventType) {
+  function forEachCallback(hostWatcherMap, id, eventPaths, cb) {
     var _a;
-    if (eventType === "update")
-      return;
-    (_a = idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
-      callback(eventPath);
+    (_a = hostWatcherMap.idToCallbacks.get(id)) == null ? void 0 : _a.forEach((callback) => {
+      eventPaths.forEach((eventPath) => cb(callback, normalizeSlashes(eventPath)));
     });
   }
 }
@@ -182919,7 +183167,6 @@ Dynamic files must always be opened with service's current directory or service
         (fileName, eventKind) => {
           switch (eventKind) {
             case 0 /* Created */:
-              return Debug.fail();
             case 1 /* Changed */:
               this.packageJsonCache.addOrUpdate(fileName, path);
               this.onPackageJsonChange(result);
@@ -187887,6 +188134,7 @@ if (typeof console !== "undefined") {
   createEmitAndSemanticDiagnosticsBuilderProgram,
   createEmitHelperFactory,
   createEmptyExports,
+  createEvaluator,
   createExpressionForJsxElement,
   createExpressionForJsxFragment,
   createExpressionForObjectLiteralElementLike,
@@ -188951,6 +189199,7 @@ if (typeof console !== "undefined") {
   isJSDocEnumTag,
   isJSDocFunctionType,
   isJSDocImplementsTag,
+  isJSDocImportTag,
   isJSDocIndexSignature,
   isJSDocLikeText,
   isJSDocLink,