typescript 5.0.0-dev.20230210 → 5.0.0-dev.20230211

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230210`;
+var version = `${versionMajorMinor}.0-dev.20230211`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -43295,6 +43295,7 @@ function createTypeChecker(host) {
   let flowTypeCache;
   const contextualTypeNodes = [];
   const contextualTypes = [];
+  const contextualIsCache = [];
   let contextualTypeCount = 0;
   const inferenceContextNodes = [];
   const inferenceContexts = [];
@@ -58256,7 +58257,12 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-    pushContextualType(next, sourcePropType);
+    pushContextualType(
+      next,
+      sourcePropType,
+      /*isCache*/
+      false
+    );
     const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
     popContextualType();
     return result;
@@ -58564,7 +58570,12 @@ function createTypeChecker(host) {
     if (isTupleLikeType(source)) {
       return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
     }
-    pushContextualType(node, target);
+    pushContextualType(
+      node,
+      target,
+      /*isCache*/
+      false
+    );
     const tupleizedType = checkArrayLiteral(
       node,
       1 /* Contextual */,
@@ -66613,11 +66624,13 @@ function createTypeChecker(host) {
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
-    const index = findContextualNode(node);
+    const index = findContextualNode(
+      node,
+      /*includeCaches*/
+      !contextFlags
+    );
     if (index >= 0) {
-      const cached = contextualTypes[index];
-      if (cached || !contextFlags)
-        return cached;
+      return contextualTypes[index];
     }
     const { parent } = node;
     switch (parent.kind) {
@@ -66688,17 +66701,30 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function pushContextualType(node, type) {
+  function pushCachedContextualType(node) {
+    pushContextualType(
+      node,
+      getContextualType(
+        node,
+        /*contextFlags*/
+        void 0
+      ),
+      /*isCache*/
+      true
+    );
+  }
+  function pushContextualType(node, type, isCache) {
     contextualTypeNodes[contextualTypeCount] = node;
     contextualTypes[contextualTypeCount] = type;
+    contextualIsCache[contextualTypeCount] = isCache;
     contextualTypeCount++;
   }
   function popContextualType() {
     contextualTypeCount--;
   }
-  function findContextualNode(node) {
+  function findContextualNode(node, includeCaches) {
     for (let i = contextualTypeCount - 1; i >= 0; i--) {
-      if (node === contextualTypeNodes[i]) {
+      if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
         return i;
       }
     }
@@ -66721,7 +66747,11 @@ function createTypeChecker(host) {
   }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-      const index = findContextualNode(node.parent);
+      const index = findContextualNode(
+        node.parent,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
         return contextualTypes[index];
       }
@@ -66992,11 +67022,7 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    pushContextualType(node, getContextualType(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const inDestructuringPattern = isAssignmentTarget(node);
     const inConstContext = isConstContext(node);
     const contextualType = getApparentTypeOfContextualType(
@@ -67159,11 +67185,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
-    pushContextualType(node, getContextualType(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const contextualType = getApparentTypeOfContextualType(
       node,
       /*contextFlags*/
@@ -73174,14 +73196,19 @@ function createTypeChecker(host) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
   }
   function getContextNode(node) {
-    if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+    if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
       return node.parent.parent;
     }
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
     const contextNode = getContextNode(node);
-    pushContextualType(contextNode, contextualType);
+    pushContextualType(
+      contextNode,
+      contextualType,
+      /*isCache*/
+      false
+    );
     pushInferenceContext(contextNode, inferenceContext);
     const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
     if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -73522,7 +73549,12 @@ function createTypeChecker(host) {
     if (links.contextFreeType) {
       return links.contextFreeType;
     }
-    pushContextualType(node, anyType);
+    pushContextualType(
+      node,
+      anyType,
+      /*isCache*/
+      false
+    );
     const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
     popContextualType();
     return type;

package/lib/tsserver.js

@@ -2287,7 +2287,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230210`;
+var version = `${versionMajorMinor}.0-dev.20230211`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -47871,6 +47871,7 @@ function createTypeChecker(host) {
   let flowTypeCache;
   const contextualTypeNodes = [];
   const contextualTypes = [];
+  const contextualIsCache = [];
   let contextualTypeCount = 0;
   const inferenceContextNodes = [];
   const inferenceContexts = [];
@@ -62832,7 +62833,12 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-    pushContextualType(next, sourcePropType);
+    pushContextualType(
+      next,
+      sourcePropType,
+      /*isCache*/
+      false
+    );
     const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
     popContextualType();
     return result;
@@ -63140,7 +63146,12 @@ function createTypeChecker(host) {
     if (isTupleLikeType(source)) {
       return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
     }
-    pushContextualType(node, target);
+    pushContextualType(
+      node,
+      target,
+      /*isCache*/
+      false
+    );
     const tupleizedType = checkArrayLiteral(
       node,
       1 /* Contextual */,
@@ -71189,11 +71200,13 @@ function createTypeChecker(host) {
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
-    const index = findContextualNode(node);
+    const index = findContextualNode(
+      node,
+      /*includeCaches*/
+      !contextFlags
+    );
     if (index >= 0) {
-      const cached = contextualTypes[index];
-      if (cached || !contextFlags)
-        return cached;
+      return contextualTypes[index];
     }
     const { parent: parent2 } = node;
     switch (parent2.kind) {
@@ -71264,17 +71277,30 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function pushContextualType(node, type) {
+  function pushCachedContextualType(node) {
+    pushContextualType(
+      node,
+      getContextualType2(
+        node,
+        /*contextFlags*/
+        void 0
+      ),
+      /*isCache*/
+      true
+    );
+  }
+  function pushContextualType(node, type, isCache) {
     contextualTypeNodes[contextualTypeCount] = node;
     contextualTypes[contextualTypeCount] = type;
+    contextualIsCache[contextualTypeCount] = isCache;
     contextualTypeCount++;
   }
   function popContextualType() {
     contextualTypeCount--;
   }
-  function findContextualNode(node) {
+  function findContextualNode(node, includeCaches) {
     for (let i = contextualTypeCount - 1; i >= 0; i--) {
-      if (node === contextualTypeNodes[i]) {
+      if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
         return i;
       }
     }
@@ -71297,7 +71323,11 @@ function createTypeChecker(host) {
   }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-      const index = findContextualNode(node.parent);
+      const index = findContextualNode(
+        node.parent,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
         return contextualTypes[index];
       }
@@ -71568,11 +71598,7 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    pushContextualType(node, getContextualType2(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const inDestructuringPattern = isAssignmentTarget(node);
     const inConstContext = isConstContext(node);
     const contextualType = getApparentTypeOfContextualType(
@@ -71735,11 +71761,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
-    pushContextualType(node, getContextualType2(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const contextualType = getApparentTypeOfContextualType(
       node,
       /*contextFlags*/
@@ -77750,14 +77772,19 @@ function createTypeChecker(host) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
   }
   function getContextNode2(node) {
-    if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+    if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
       return node.parent.parent;
     }
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
     const contextNode = getContextNode2(node);
-    pushContextualType(contextNode, contextualType);
+    pushContextualType(
+      contextNode,
+      contextualType,
+      /*isCache*/
+      false
+    );
     pushInferenceContext(contextNode, inferenceContext);
     const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
     if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -78098,7 +78125,12 @@ function createTypeChecker(host) {
     if (links.contextFreeType) {
       return links.contextFreeType;
     }
-    pushContextualType(node, anyType);
+    pushContextualType(
+      node,
+      anyType,
+      /*isCache*/
+      false
+    );
     const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
     popContextualType();
     return type;
@@ -141231,6 +141263,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       sourceFile,
       symbol,
       symbolName2,
+      moduleSymbol,
       /*isJsxTagName*/
       false,
       program,
@@ -141242,7 +141275,6 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
     const fix = getImportFixForSymbol(
       sourceFile,
       Debug.checkDefined(exportInfo),
-      moduleSymbol,
       program,
       /*position*/
       void 0,
@@ -141420,13 +141452,19 @@ function createImportSpecifierResolver(importingFile, program, host, preferences
     return result && { ...result, computedWithoutCacheCount };
   }
 }
-function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
+function getImportCompletionAction(targetSymbol, moduleSymbol, exportMapKey, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
   const compilerOptions = program.getCompilerOptions();
-  const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
-  Debug.assertIsDefined(exportInfos);
+  let exportInfos;
+  if (exportMapKey) {
+    exportInfos = getExportInfoMap(sourceFile, host, program, preferences, cancellationToken).get(sourceFile.path, exportMapKey);
+    Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified exportMapKey");
+  } else {
+    exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, symbolName2, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, moduleSymbol, isJsxTagName, program, host, preferences, cancellationToken);
+    Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified symbol / moduleSymbol");
+  }
   const useRequire = shouldUseRequire(sourceFile, program);
   const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
-  const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
+  const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
   return {
     moduleSpecifier: fix.moduleSpecifier,
     codeAction: codeFixActionToCodeAction(codeActionForFix(
@@ -141448,23 +141486,22 @@ function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, ho
   const includeSymbolNameInDescription = symbolName2 !== symbolToken.text;
   return fix && codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName2, fix, includeSymbolNameInDescription, compilerOptions, preferences));
 }
-function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
-  Debug.assert(exportInfos.some((info) => info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
+function getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
   const packageJsonImportFilter = createPackageJsonImportFilter(sourceFile, preferences, host);
   return getBestFix(getImportFixes(exportInfos, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
 }
 function codeFixActionToCodeAction({ description: description2, changes, commands }) {
   return { description: description2, changes, commands };
 }
-function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, preferCapitalized, program, host, preferences, cancellationToken) {
+function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSymbol, preferCapitalized, program, host, preferences, cancellationToken) {
   const getChecker = createGetChecker(program, host);
   return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => {
-    if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) {
+    if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol && info.some((i) => i.moduleSymbol === moduleSymbol || i.symbol.parent === moduleSymbol)) {
       return info;
     }
   });
 }
-function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
+function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program, host) {
   var _a2, _b;
   const compilerOptions = program.getCompilerOptions();
   const mainProgramInfo = getInfoWithChecker(
@@ -141486,7 +141523,7 @@ function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
     if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
       return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
-    const named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol);
+    const named = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
     if (named && skipAlias(named, checker) === symbol) {
       return { symbol: named, moduleSymbol, moduleFileName: void 0, exportKind: 0 /* Named */, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
@@ -149145,6 +149182,7 @@ function originToCompletionEntryData(origin) {
   if (originIsResolvedExport(origin)) {
     const resolvedData = {
       exportName: origin.exportName,
+      exportMapKey: origin.exportMapKey,
       moduleSpecifier: origin.moduleSpecifier,
       ambientModuleName,
       fileName: origin.fileName,
@@ -149168,6 +149206,7 @@ function completionEntryDataToSymbolOriginInfo(data, completionName, moduleSymbo
     const resolvedOrigin = {
       kind: 32 /* ResolvedExport */,
       exportName: data.exportName,
+      exportMapKey: data.exportMapKey,
       moduleSpecifier: data.moduleSpecifier,
       symbolName: completionName,
       fileName: data.fileName,
@@ -149546,6 +149585,7 @@ function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextTo
   const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
     targetSymbol,
     moduleSymbol,
+    data == null ? void 0 : data.exportMapKey,
     sourceFile,
     name,
     isJsxOpeningTagName,
@@ -150244,16 +150284,16 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
             if (detailsEntryId && !some(info, (i) => detailsEntryId.source === stripQuotes(i.moduleSymbol.name))) {
               return;
             }
-            const firstImportableExportInfo = find(info, isImportableExportInfo);
-            if (!firstImportableExportInfo) {
+            info = filter(info, isImportableExportInfo);
+            if (!info.length) {
               return;
             }
             const result = context.tryResolve(info, isFromAmbientModule) || {};
             if (result === "failed")
               return;
-            let exportInfo2 = firstImportableExportInfo, moduleSpecifier;
+            let exportInfo2 = info[0], moduleSpecifier;
             if (result !== "skipped") {
-              ({ exportInfo: exportInfo2 = firstImportableExportInfo, moduleSpecifier } = result);
+              ({ exportInfo: exportInfo2 = info[0], moduleSpecifier } = result);
             }
             const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
             const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;

package/lib/tsserverlibrary.d.ts

@@ -10590,6 +10590,7 @@ declare namespace ts {
          * in the case of InternalSymbolName.ExportEquals and InternalSymbolName.Default.
          */
         exportName: string;
+        exportMapKey?: string;
         moduleSpecifier?: string;
         /** The file name declaring the export's module symbol, if it was an external module */
         fileName?: string;
@@ -10599,7 +10600,6 @@ declare namespace ts {
         isPackageJsonImport?: true;
     }
     interface CompletionEntryDataUnresolved extends CompletionEntryDataAutoImport {
-        /** The key in the `ExportMapCache` where the completion entry's `SymbolExportInfo[]` is found */
         exportMapKey: string;
     }
     interface CompletionEntryDataResolved extends CompletionEntryDataAutoImport {

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230210`;
+      version = `${versionMajorMinor}.0-dev.20230211`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -45681,6 +45681,7 @@ ${lanes.join("\n")}
     let flowTypeCache;
     const contextualTypeNodes = [];
     const contextualTypes = [];
+    const contextualIsCache = [];
     let contextualTypeCount = 0;
     const inferenceContextNodes = [];
     const inferenceContexts = [];
@@ -60642,7 +60643,12 @@ ${lanes.join("\n")}
       }
     }
     function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-      pushContextualType(next, sourcePropType);
+      pushContextualType(
+        next,
+        sourcePropType,
+        /*isCache*/
+        false
+      );
       const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
       popContextualType();
       return result;
@@ -60950,7 +60956,12 @@ ${lanes.join("\n")}
       if (isTupleLikeType(source)) {
         return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
       }
-      pushContextualType(node, target);
+      pushContextualType(
+        node,
+        target,
+        /*isCache*/
+        false
+      );
       const tupleizedType = checkArrayLiteral(
         node,
         1 /* Contextual */,
@@ -68999,11 +69010,13 @@ ${lanes.join("\n")}
       if (node.flags & 33554432 /* InWithStatement */) {
         return void 0;
       }
-      const index = findContextualNode(node);
+      const index = findContextualNode(
+        node,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
-        const cached = contextualTypes[index];
-        if (cached || !contextFlags)
-          return cached;
+        return contextualTypes[index];
       }
       const { parent: parent2 } = node;
       switch (parent2.kind) {
@@ -69074,17 +69087,30 @@ ${lanes.join("\n")}
       }
       return void 0;
     }
-    function pushContextualType(node, type) {
+    function pushCachedContextualType(node) {
+      pushContextualType(
+        node,
+        getContextualType2(
+          node,
+          /*contextFlags*/
+          void 0
+        ),
+        /*isCache*/
+        true
+      );
+    }
+    function pushContextualType(node, type, isCache) {
       contextualTypeNodes[contextualTypeCount] = node;
       contextualTypes[contextualTypeCount] = type;
+      contextualIsCache[contextualTypeCount] = isCache;
       contextualTypeCount++;
     }
     function popContextualType() {
       contextualTypeCount--;
     }
-    function findContextualNode(node) {
+    function findContextualNode(node, includeCaches) {
       for (let i = contextualTypeCount - 1; i >= 0; i--) {
-        if (node === contextualTypeNodes[i]) {
+        if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
           return i;
         }
       }
@@ -69107,7 +69133,11 @@ ${lanes.join("\n")}
     }
     function getContextualJsxElementAttributesType(node, contextFlags) {
       if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-        const index = findContextualNode(node.parent);
+        const index = findContextualNode(
+          node.parent,
+          /*includeCaches*/
+          !contextFlags
+        );
         if (index >= 0) {
           return contextualTypes[index];
         }
@@ -69378,11 +69408,7 @@ ${lanes.join("\n")}
       const elementCount = elements.length;
       const elementTypes = [];
       const elementFlags = [];
-      pushContextualType(node, getContextualType2(
-        node,
-        /*contextFlags*/
-        void 0
-      ));
+      pushCachedContextualType(node);
       const inDestructuringPattern = isAssignmentTarget(node);
       const inConstContext = isConstContext(node);
       const contextualType = getApparentTypeOfContextualType(
@@ -69545,11 +69571,7 @@ ${lanes.join("\n")}
       let propertiesTable = createSymbolTable();
       let propertiesArray = [];
       let spread = emptyObjectType;
-      pushContextualType(node, getContextualType2(
-        node,
-        /*contextFlags*/
-        void 0
-      ));
+      pushCachedContextualType(node);
       const contextualType = getApparentTypeOfContextualType(
         node,
         /*contextFlags*/
@@ -75560,14 +75582,19 @@ ${lanes.join("\n")}
       return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
     }
     function getContextNode2(node) {
-      if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+      if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
         return node.parent.parent;
       }
       return node;
     }
     function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
       const contextNode = getContextNode2(node);
-      pushContextualType(contextNode, contextualType);
+      pushContextualType(
+        contextNode,
+        contextualType,
+        /*isCache*/
+        false
+      );
       pushInferenceContext(contextNode, inferenceContext);
       const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
       if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -75908,7 +75935,12 @@ ${lanes.join("\n")}
       if (links.contextFreeType) {
         return links.contextFreeType;
       }
-      pushContextualType(node, anyType);
+      pushContextualType(
+        node,
+        anyType,
+        /*isCache*/
+        false
+      );
       const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
       popContextualType();
       return type;
@@ -139784,6 +139816,7 @@ ${lanes.join("\n")}
         sourceFile,
         symbol,
         symbolName2,
+        moduleSymbol,
         /*isJsxTagName*/
         false,
         program,
@@ -139795,7 +139828,6 @@ ${lanes.join("\n")}
       const fix = getImportFixForSymbol(
         sourceFile,
         Debug.checkDefined(exportInfo),
-        moduleSymbol,
         program,
         /*position*/
         void 0,
@@ -139973,13 +140005,19 @@ ${lanes.join("\n")}
       return result && { ...result, computedWithoutCacheCount };
     }
   }
-  function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
+  function getImportCompletionAction(targetSymbol, moduleSymbol, exportMapKey, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
     const compilerOptions = program.getCompilerOptions();
-    const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
-    Debug.assertIsDefined(exportInfos);
+    let exportInfos;
+    if (exportMapKey) {
+      exportInfos = getExportInfoMap(sourceFile, host, program, preferences, cancellationToken).get(sourceFile.path, exportMapKey);
+      Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified exportMapKey");
+    } else {
+      exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, symbolName2, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, moduleSymbol, isJsxTagName, program, host, preferences, cancellationToken);
+      Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified symbol / moduleSymbol");
+    }
     const useRequire = shouldUseRequire(sourceFile, program);
     const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
-    const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
+    const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
     return {
       moduleSpecifier: fix.moduleSpecifier,
       codeAction: codeFixActionToCodeAction(codeActionForFix(
@@ -140001,23 +140039,22 @@ ${lanes.join("\n")}
     const includeSymbolNameInDescription = symbolName2 !== symbolToken.text;
     return fix && codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName2, fix, includeSymbolNameInDescription, compilerOptions, preferences));
   }
-  function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
-    Debug.assert(exportInfos.some((info) => info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
+  function getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
     const packageJsonImportFilter = createPackageJsonImportFilter(sourceFile, preferences, host);
     return getBestFix(getImportFixes(exportInfos, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
   }
   function codeFixActionToCodeAction({ description: description2, changes, commands }) {
     return { description: description2, changes, commands };
   }
-  function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, preferCapitalized, program, host, preferences, cancellationToken) {
+  function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSymbol, preferCapitalized, program, host, preferences, cancellationToken) {
     const getChecker = createGetChecker(program, host);
     return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => {
-      if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) {
+      if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol && info.some((i) => i.moduleSymbol === moduleSymbol || i.symbol.parent === moduleSymbol)) {
         return info;
       }
     });
   }
-  function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
+  function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program, host) {
     var _a2, _b;
     const compilerOptions = program.getCompilerOptions();
     const mainProgramInfo = getInfoWithChecker(
@@ -140039,7 +140076,7 @@ ${lanes.join("\n")}
       if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
         return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
       }
-      const named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol);
+      const named = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
       if (named && skipAlias(named, checker) === symbol) {
         return { symbol: named, moduleSymbol, moduleFileName: void 0, exportKind: 0 /* Named */, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
       }
@@ -148200,6 +148237,7 @@ ${lanes.join("\n")}
     if (originIsResolvedExport(origin)) {
       const resolvedData = {
         exportName: origin.exportName,
+        exportMapKey: origin.exportMapKey,
         moduleSpecifier: origin.moduleSpecifier,
         ambientModuleName,
         fileName: origin.fileName,
@@ -148223,6 +148261,7 @@ ${lanes.join("\n")}
       const resolvedOrigin = {
         kind: 32 /* ResolvedExport */,
         exportName: data.exportName,
+        exportMapKey: data.exportMapKey,
         moduleSpecifier: data.moduleSpecifier,
         symbolName: completionName,
         fileName: data.fileName,
@@ -148601,6 +148640,7 @@ ${lanes.join("\n")}
     const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
       targetSymbol,
       moduleSymbol,
+      data == null ? void 0 : data.exportMapKey,
       sourceFile,
       name,
       isJsxOpeningTagName,
@@ -149290,16 +149330,16 @@ ${lanes.join("\n")}
               if (detailsEntryId && !some(info, (i) => detailsEntryId.source === stripQuotes(i.moduleSymbol.name))) {
                 return;
               }
-              const firstImportableExportInfo = find(info, isImportableExportInfo);
-              if (!firstImportableExportInfo) {
+              info = filter(info, isImportableExportInfo);
+              if (!info.length) {
                 return;
               }
               const result = context.tryResolve(info, isFromAmbientModule) || {};
               if (result === "failed")
                 return;
-              let exportInfo2 = firstImportableExportInfo, moduleSpecifier;
+              let exportInfo2 = info[0], moduleSpecifier;
               if (result !== "skipped") {
-                ({ exportInfo: exportInfo2 = firstImportableExportInfo, moduleSpecifier } = result);
+                ({ exportInfo: exportInfo2 = info[0], moduleSpecifier } = result);
               }
               const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
               const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;

package/lib/typescript.d.ts

@@ -6688,6 +6688,7 @@ declare namespace ts {
          * in the case of InternalSymbolName.ExportEquals and InternalSymbolName.Default.
          */
         exportName: string;
+        exportMapKey?: string;
         moduleSpecifier?: string;
         /** The file name declaring the export's module symbol, if it was an external module */
         fileName?: string;
@@ -6697,7 +6698,6 @@ declare namespace ts {
         isPackageJsonImport?: true;
     }
     interface CompletionEntryDataUnresolved extends CompletionEntryDataAutoImport {
-        /** The key in the `ExportMapCache` where the completion entry's `SymbolExportInfo[]` is found */
         exportMapKey: string;
     }
     interface CompletionEntryDataResolved extends CompletionEntryDataAutoImport {

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230210`;
+      version = `${versionMajorMinor}.0-dev.20230211`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -45681,6 +45681,7 @@ ${lanes.join("\n")}
     let flowTypeCache;
     const contextualTypeNodes = [];
     const contextualTypes = [];
+    const contextualIsCache = [];
     let contextualTypeCount = 0;
     const inferenceContextNodes = [];
     const inferenceContexts = [];
@@ -60642,7 +60643,12 @@ ${lanes.join("\n")}
       }
     }
     function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-      pushContextualType(next, sourcePropType);
+      pushContextualType(
+        next,
+        sourcePropType,
+        /*isCache*/
+        false
+      );
       const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
       popContextualType();
       return result;
@@ -60950,7 +60956,12 @@ ${lanes.join("\n")}
       if (isTupleLikeType(source)) {
         return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
       }
-      pushContextualType(node, target);
+      pushContextualType(
+        node,
+        target,
+        /*isCache*/
+        false
+      );
       const tupleizedType = checkArrayLiteral(
         node,
         1 /* Contextual */,
@@ -68999,11 +69010,13 @@ ${lanes.join("\n")}
       if (node.flags & 33554432 /* InWithStatement */) {
         return void 0;
       }
-      const index = findContextualNode(node);
+      const index = findContextualNode(
+        node,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
-        const cached = contextualTypes[index];
-        if (cached || !contextFlags)
-          return cached;
+        return contextualTypes[index];
       }
       const { parent: parent2 } = node;
       switch (parent2.kind) {
@@ -69074,17 +69087,30 @@ ${lanes.join("\n")}
       }
       return void 0;
     }
-    function pushContextualType(node, type) {
+    function pushCachedContextualType(node) {
+      pushContextualType(
+        node,
+        getContextualType2(
+          node,
+          /*contextFlags*/
+          void 0
+        ),
+        /*isCache*/
+        true
+      );
+    }
+    function pushContextualType(node, type, isCache) {
       contextualTypeNodes[contextualTypeCount] = node;
       contextualTypes[contextualTypeCount] = type;
+      contextualIsCache[contextualTypeCount] = isCache;
       contextualTypeCount++;
     }
     function popContextualType() {
       contextualTypeCount--;
     }
-    function findContextualNode(node) {
+    function findContextualNode(node, includeCaches) {
       for (let i = contextualTypeCount - 1; i >= 0; i--) {
-        if (node === contextualTypeNodes[i]) {
+        if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
           return i;
         }
       }
@@ -69107,7 +69133,11 @@ ${lanes.join("\n")}
     }
     function getContextualJsxElementAttributesType(node, contextFlags) {
       if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-        const index = findContextualNode(node.parent);
+        const index = findContextualNode(
+          node.parent,
+          /*includeCaches*/
+          !contextFlags
+        );
         if (index >= 0) {
           return contextualTypes[index];
         }
@@ -69378,11 +69408,7 @@ ${lanes.join("\n")}
       const elementCount = elements.length;
       const elementTypes = [];
       const elementFlags = [];
-      pushContextualType(node, getContextualType2(
-        node,
-        /*contextFlags*/
-        void 0
-      ));
+      pushCachedContextualType(node);
       const inDestructuringPattern = isAssignmentTarget(node);
       const inConstContext = isConstContext(node);
       const contextualType = getApparentTypeOfContextualType(
@@ -69545,11 +69571,7 @@ ${lanes.join("\n")}
       let propertiesTable = createSymbolTable();
       let propertiesArray = [];
       let spread = emptyObjectType;
-      pushContextualType(node, getContextualType2(
-        node,
-        /*contextFlags*/
-        void 0
-      ));
+      pushCachedContextualType(node);
       const contextualType = getApparentTypeOfContextualType(
         node,
         /*contextFlags*/
@@ -75560,14 +75582,19 @@ ${lanes.join("\n")}
       return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
     }
     function getContextNode2(node) {
-      if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+      if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
         return node.parent.parent;
       }
       return node;
     }
     function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
       const contextNode = getContextNode2(node);
-      pushContextualType(contextNode, contextualType);
+      pushContextualType(
+        contextNode,
+        contextualType,
+        /*isCache*/
+        false
+      );
       pushInferenceContext(contextNode, inferenceContext);
       const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
       if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -75908,7 +75935,12 @@ ${lanes.join("\n")}
       if (links.contextFreeType) {
         return links.contextFreeType;
       }
-      pushContextualType(node, anyType);
+      pushContextualType(
+        node,
+        anyType,
+        /*isCache*/
+        false
+      );
       const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
       popContextualType();
       return type;
@@ -139798,6 +139830,7 @@ ${lanes.join("\n")}
         sourceFile,
         symbol,
         symbolName2,
+        moduleSymbol,
         /*isJsxTagName*/
         false,
         program,
@@ -139809,7 +139842,6 @@ ${lanes.join("\n")}
       const fix = getImportFixForSymbol(
         sourceFile,
         Debug.checkDefined(exportInfo),
-        moduleSymbol,
         program,
         /*position*/
         void 0,
@@ -139987,13 +140019,19 @@ ${lanes.join("\n")}
       return result && { ...result, computedWithoutCacheCount };
     }
   }
-  function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
+  function getImportCompletionAction(targetSymbol, moduleSymbol, exportMapKey, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
     const compilerOptions = program.getCompilerOptions();
-    const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
-    Debug.assertIsDefined(exportInfos);
+    let exportInfos;
+    if (exportMapKey) {
+      exportInfos = getExportInfoMap(sourceFile, host, program, preferences, cancellationToken).get(sourceFile.path, exportMapKey);
+      Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified exportMapKey");
+    } else {
+      exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, symbolName2, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, moduleSymbol, isJsxTagName, program, host, preferences, cancellationToken);
+      Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified symbol / moduleSymbol");
+    }
     const useRequire = shouldUseRequire(sourceFile, program);
     const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
-    const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
+    const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
     return {
       moduleSpecifier: fix.moduleSpecifier,
       codeAction: codeFixActionToCodeAction(codeActionForFix(
@@ -140015,23 +140053,22 @@ ${lanes.join("\n")}
     const includeSymbolNameInDescription = symbolName2 !== symbolToken.text;
     return fix && codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName2, fix, includeSymbolNameInDescription, compilerOptions, preferences));
   }
-  function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
-    Debug.assert(exportInfos.some((info) => info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
+  function getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
     const packageJsonImportFilter = createPackageJsonImportFilter(sourceFile, preferences, host);
     return getBestFix(getImportFixes(exportInfos, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
   }
   function codeFixActionToCodeAction({ description: description2, changes, commands }) {
     return { description: description2, changes, commands };
   }
-  function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, preferCapitalized, program, host, preferences, cancellationToken) {
+  function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSymbol, preferCapitalized, program, host, preferences, cancellationToken) {
     const getChecker = createGetChecker(program, host);
     return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => {
-      if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) {
+      if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol && info.some((i) => i.moduleSymbol === moduleSymbol || i.symbol.parent === moduleSymbol)) {
         return info;
       }
     });
   }
-  function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
+  function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program, host) {
     var _a2, _b;
     const compilerOptions = program.getCompilerOptions();
     const mainProgramInfo = getInfoWithChecker(
@@ -140053,7 +140090,7 @@ ${lanes.join("\n")}
       if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
         return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
       }
-      const named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol);
+      const named = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
       if (named && skipAlias(named, checker) === symbol) {
         return { symbol: named, moduleSymbol, moduleFileName: void 0, exportKind: 0 /* Named */, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
       }
@@ -148214,6 +148251,7 @@ ${lanes.join("\n")}
     if (originIsResolvedExport(origin)) {
       const resolvedData = {
         exportName: origin.exportName,
+        exportMapKey: origin.exportMapKey,
         moduleSpecifier: origin.moduleSpecifier,
         ambientModuleName,
         fileName: origin.fileName,
@@ -148237,6 +148275,7 @@ ${lanes.join("\n")}
       const resolvedOrigin = {
         kind: 32 /* ResolvedExport */,
         exportName: data.exportName,
+        exportMapKey: data.exportMapKey,
         moduleSpecifier: data.moduleSpecifier,
         symbolName: completionName,
         fileName: data.fileName,
@@ -148615,6 +148654,7 @@ ${lanes.join("\n")}
     const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
       targetSymbol,
       moduleSymbol,
+      data == null ? void 0 : data.exportMapKey,
       sourceFile,
       name,
       isJsxOpeningTagName,
@@ -149304,16 +149344,16 @@ ${lanes.join("\n")}
               if (detailsEntryId && !some(info, (i) => detailsEntryId.source === stripQuotes(i.moduleSymbol.name))) {
                 return;
               }
-              const firstImportableExportInfo = find(info, isImportableExportInfo);
-              if (!firstImportableExportInfo) {
+              info = filter(info, isImportableExportInfo);
+              if (!info.length) {
                 return;
               }
               const result = context.tryResolve(info, isFromAmbientModule) || {};
               if (result === "failed")
                 return;
-              let exportInfo2 = firstImportableExportInfo, moduleSpecifier;
+              let exportInfo2 = info[0], moduleSpecifier;
               if (result !== "skipped") {
-                ({ exportInfo: exportInfo2 = firstImportableExportInfo, moduleSpecifier } = result);
+                ({ exportInfo: exportInfo2 = info[0], moduleSpecifier } = result);
               }
               const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
               const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230210`;
+var version = `${versionMajorMinor}.0-dev.20230211`;
 
 // src/compiler/core.ts
 var emptyArray = [];

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.0.0-dev.20230210",
+    "version": "5.0.0-dev.20230211",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [