typescript 4.7.0-dev.20220504 → 4.8.0-dev.20220507

package/lib/tsserver.js

@@ -96,11 +96,11 @@ var ts;
 (function (ts) {
     // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
     // If changing the text in this section, be sure to test `configurePrerelease` too.
-    ts.versionMajorMinor = "4.7";
+    ts.versionMajorMinor = "4.8";
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220504";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220507";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8409,6 +8409,8 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
+        The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -8998,6 +9000,7 @@ var ts;
         This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0: diag(4122, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4122", "This member cannot have a JSDoc comment with an '@override' tag because it is not declared in the base class '{0}'."),
         This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4123, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4123", "This member cannot have a JSDoc comment with an 'override' tag because it is not declared in the base class '{0}'. Did you mean '{1}'?"),
         Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4124, ts.DiagnosticCategory.Error, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
+        Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4125, ts.DiagnosticCategory.Error, "Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_wi_4125", "Resolution mode assertions are unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
         The_current_host_does_not_support_the_0_option: diag(5001, ts.DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."),
         Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts.DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."),
         File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts.DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."),
@@ -18004,6 +18007,10 @@ var ts;
         return indentStrings[1].length;
     }
     ts.getIndentSize = getIndentSize;
+    function isNightly() {
+        return ts.stringContains(ts.version, "-dev") || ts.stringContains(ts.version, "-insiders");
+    }
+    ts.isNightly = isNightly;
     function createTextWriter(newLine) {
         var output;
         var indent;
@@ -18234,6 +18241,16 @@ var ts;
                     ".d.ts" /* Dts */;
     }
     ts.getDeclarationEmitExtensionForPath = getDeclarationEmitExtensionForPath;
+    /**
+     * This function is an inverse of `getDeclarationEmitExtensionForPath`.
+     */
+    function getPossibleOriginalInputExtensionForExtension(path) {
+        return ts.fileExtensionIsOneOf(path, [".d.mts" /* Dmts */, ".mjs" /* Mjs */, ".mts" /* Mts */]) ? [".mts" /* Mts */, ".mjs" /* Mjs */] :
+            ts.fileExtensionIsOneOf(path, [".d.cts" /* Dcts */, ".cjs" /* Cjs */, ".cts" /* Cts */]) ? [".cts" /* Cts */, ".cjs" /* Cjs */] :
+                ts.fileExtensionIsOneOf(path, [".json.d.ts"]) ? [".json" /* Json */] :
+                    [".tsx" /* Tsx */, ".ts" /* Ts */, ".jsx" /* Jsx */, ".js" /* Js */];
+    }
+    ts.getPossibleOriginalInputExtensionForExtension = getPossibleOriginalInputExtensionForExtension;
     function outFile(options) {
         return options.outFile || options.out;
     }
@@ -26183,7 +26200,7 @@ var ts;
             return node;
         }
         function cloneSourceFileWithChanges(source, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
-            var node = baseFactory.createBaseSourceFileNode(305 /* SourceFile */);
+            var node = (source.redirectInfo ? Object.create(source.redirectInfo.redirectTarget) : baseFactory.createBaseSourceFileNode(305 /* SourceFile */));
             for (var p in source) {
                 if (p === "emitNode" || ts.hasProperty(node, p) || !ts.hasProperty(source, p))
                     continue;
@@ -31308,7 +31325,7 @@ var ts;
             initializeState("", content, languageVersion, /*syntaxCursor*/ undefined, 1 /* JS */);
             // Prime the scanner.
             nextToken();
-            var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ false);
+            var entityName = parseEntityName(/*allowReservedWords*/ true);
             var isInvalid = token() === 1 /* EndOfFileToken */ && !parseDiagnostics.length;
             clearState();
             return isInvalid ? entityName : undefined;
@@ -32841,6 +32858,7 @@ var ts;
                     var startPos = scanner.getStartPos();
                     var result = parseListElement(kind, parseElement);
                     if (!result) {
+                        parsingContext = saveParsingContext;
                         return undefined;
                     }
                     list.push(result);
@@ -32908,7 +32926,7 @@ var ts;
             }
             return createMissingList();
         }
-        function parseEntityName(allowReservedWords, allowPrivateIdentifiers, diagnosticMessage) {
+        function parseEntityName(allowReservedWords, diagnosticMessage) {
             var pos = getNodePos();
             var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
             var dotPos = getNodePos();
@@ -32919,7 +32937,7 @@ var ts;
                     break;
                 }
                 dotPos = getNodePos();
-                entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, allowPrivateIdentifiers)), pos);
+                entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, /* allowPrivateIdentifiers */ false)), pos);
             }
             return entity;
         }
@@ -33052,7 +33070,7 @@ var ts;
         }
         // TYPES
         function parseEntityNameOfTypeReference() {
-            return parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ false, ts.Diagnostics.Type_expected);
+            return parseEntityName(/*allowReservedWords*/ true, ts.Diagnostics.Type_expected);
         }
         function parseTypeArgumentsOfTypeReference() {
             if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* LessThanToken */) {
@@ -33185,7 +33203,7 @@ var ts;
         function parseTypeQuery() {
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
-            var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
+            var entityName = parseEntityName(/*allowReservedWords*/ true);
             // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
             var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
@@ -34153,10 +34171,10 @@ var ts;
                 setDecoratorContext(/*val*/ false);
             }
             var pos = getNodePos();
-            var expr = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
+            var expr = parseAssignmentExpressionOrHigher();
             var operatorToken;
             while ((operatorToken = parseOptionalToken(27 /* CommaToken */))) {
-                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false), pos);
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
             }
             if (saveDecoratorContext) {
                 setDecoratorContext(/*val*/ true);
@@ -34164,9 +34182,9 @@ var ts;
             return expr;
         }
         function parseInitializer() {
-            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false) : undefined;
+            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
         }
-        function parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) {
+        function parseAssignmentExpressionOrHigher() {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -34192,7 +34210,7 @@ var ts;
             // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction);
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -34211,7 +34229,7 @@ var ts;
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
             if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-                return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, /*asyncModifier*/ undefined);
+                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined);
             }
             // Now see if we might be in cases '2' or '3'.
             // If the expression was a LHS expression, and we have an assignment operator, then
@@ -34220,7 +34238,7 @@ var ts;
             // Note: we call reScanGreaterToken so that we get an appropriately merged token
             // for cases like `> > =` becoming `>>=`
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
-                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
             return parseConditionalExpressionRest(expr, pos);
@@ -34263,7 +34281,7 @@ var ts;
             nextToken();
             if (!scanner.hasPrecedingLineBreak() &&
                 (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
-                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false)), pos);
+                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher()), pos);
             }
             else {
                 // if the next token is not on the same line as yield.  or we don't have an '*' or
@@ -34271,7 +34289,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, disallowReturnTypeInArrowFunction, asyncModifier) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
             ts.Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(
             /*decorators*/ undefined, 
@@ -34283,11 +34301,11 @@ var ts;
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
-            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, disallowReturnTypeInArrowFunction);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
+        function tryParseParenthesizedArrowFunctionExpression() {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -34298,8 +34316,8 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
-                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true) :
+                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -34429,25 +34447,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
+        function parsePossibleParenthesizedArrowFunctionExpression() {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, disallowReturnTypeInArrowFunction);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
+        function tryParseAsyncSimpleArrowFunctionExpression() {
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() === 131 /* AsyncKeyword */) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
-                    return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, asyncModifier);
+                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
                 }
             }
             return undefined;
@@ -34471,7 +34489,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, disallowReturnTypeInArrowFunction) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -34506,23 +34524,6 @@ var ts;
                     return undefined;
                 }
             }
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
-                return undefined;
-            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34551,12 +34552,12 @@ var ts;
             var lastToken = token();
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
-                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
+                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
                 : parseIdentifier();
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync, disallowReturnTypeInArrowFunction) {
+        function parseArrowFunctionExpressionBody(isAsync) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -34584,8 +34585,8 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); })
-                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); });
+                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
+                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
             topLevel = savedTopLevel;
             return node;
         }
@@ -34598,8 +34599,8 @@ var ts;
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ true)
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher()
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -35491,13 +35492,13 @@ var ts;
         function parseSpreadElement() {
             var pos = getNodePos();
             parseExpected(25 /* DotDotDotToken */);
-            var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
+            var expression = parseAssignmentExpressionOrHigher();
             return finishNode(factory.createSpreadElement(expression), pos);
         }
         function parseArgumentOrArrayLiteralElement() {
             return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() :
                 token() === 27 /* CommaToken */ ? finishNode(factory.createOmittedExpression(), getNodePos()) :
-                    parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
+                    parseAssignmentExpressionOrHigher();
         }
         function parseArgumentExpression() {
             return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
@@ -35515,7 +35516,7 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             if (parseOptionalToken(25 /* DotDotDotToken */)) {
-                var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
+                var expression = parseAssignmentExpressionOrHigher();
                 return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
             }
             var decorators = parseDecorators();
@@ -35544,7 +35545,7 @@ var ts;
             var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58 /* ColonToken */);
             if (isShorthandPropertyAssignment) {
                 var equalsToken = parseOptionalToken(63 /* EqualsToken */);
-                var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); }) : undefined;
+                var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
                 node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
                 // Save equals token for error reporting.
                 // TODO(rbuckton): Consider manufacturing this when we need to report an error as it is otherwise not useful.
@@ -35552,7 +35553,7 @@ var ts;
             }
             else {
                 parseExpected(58 /* ColonToken */);
-                var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); });
+                var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
                 node = factory.createPropertyAssignment(name, initializer);
             }
             // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker
@@ -35726,7 +35727,7 @@ var ts;
             }
             var node;
             if (awaitToken ? parseExpected(160 /* OfKeyword */) : parseOptional(160 /* OfKeyword */)) {
-                var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false); });
+                var expression = allowInAnd(parseAssignmentExpressionOrHigher);
                 parseExpected(21 /* CloseParenToken */);
                 node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
             }
@@ -36894,7 +36895,7 @@ var ts;
             var pos = getNodePos();
             var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
             parseExpected(58 /* ColonToken */);
-            var value = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
+            var value = parseAssignmentExpressionOrHigher();
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
         function parseAssertClause(skipAssertKeyword) {
@@ -36954,7 +36955,7 @@ var ts;
         function parseModuleReference() {
             return isExternalModuleReference()
                 ? parseExternalModuleReference()
-                : parseEntityName(/*allowReservedWords*/ false, /*allowPrivateIdentifiers*/ false);
+                : parseEntityName(/*allowReservedWords*/ false);
         }
         function parseExternalModuleReference() {
             var pos = getNodePos();
@@ -37133,7 +37134,7 @@ var ts;
             else {
                 parseExpected(88 /* DefaultKeyword */);
             }
-            var expression = parseAssignmentExpressionOrHigher(/*disallowReturnTypeInArrowFunction*/ false);
+            var expression = parseAssignmentExpressionOrHigher();
             parseSemicolon();
             setAwaitContext(savedAwaitContext);
             var node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);
@@ -37207,7 +37208,7 @@ var ts;
                 var pos = getNodePos();
                 var hasBrace = parseOptional(18 /* OpenBraceToken */);
                 var p2 = getNodePos();
-                var entityName = parseEntityName(/* allowReservedWords*/ false, /*allowPrivateIdentifiers*/ false);
+                var entityName = parseEntityName(/* allowReservedWords*/ false);
                 while (token() === 80 /* PrivateIdentifier */) {
                     reScanHashToken(); // rescan #id as # id
                     nextTokenJSDoc(); // then skip the #
@@ -37650,7 +37651,7 @@ var ts;
                     // parseEntityName logs an error for non-identifier, so create a MissingNode ourselves to avoid the error
                     var p2 = getNodePos();
                     var name = ts.tokenIsIdentifierOrKeyword(token())
-                        ? parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ false)
+                        ? parseEntityName(/*allowReservedWords*/ true)
                         : undefined;
                     if (name) {
                         while (token() === 80 /* PrivateIdentifier */) {
@@ -38972,6 +38973,7 @@ var ts;
         ["es2021.intl", "lib.es2021.intl.d.ts"],
         ["es2022.array", "lib.es2022.array.d.ts"],
         ["es2022.error", "lib.es2022.error.d.ts"],
+        ["es2022.intl", "lib.es2022.intl.d.ts"],
         ["es2022.object", "lib.es2022.object.d.ts"],
         ["es2022.string", "lib.es2022.string.d.ts"],
         ["esnext.array", "lib.es2022.array.d.ts"],
@@ -42170,7 +42172,7 @@ var ts;
         ts.Debug.assert(ts.extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
     }
-    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, resultFromCache) {
+    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, diagnostics, resultFromCache) {
         var _a;
         if (resultFromCache) {
             (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
@@ -42178,7 +42180,8 @@ var ts;
         }
         return {
             resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
-            failedLookupLocations: failedLookupLocations
+            failedLookupLocations: failedLookupLocations,
+            resolutionDiagnostics: diagnostics
         };
     }
     function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
@@ -42379,7 +42382,18 @@ var ts;
             features |= NodeResolutionFeatures.EsmMode;
         }
         var conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : [];
-        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: conditions };
+        var diagnostics = [];
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: traceEnabled,
+            failedLookupLocations: failedLookupLocations,
+            packageJsonInfoCache: cache,
+            features: features,
+            conditions: conditions,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+        };
         var resolved = primaryLookup();
         var primary = true;
         if (!resolved) {
@@ -42398,7 +42412,7 @@ var ts;
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
         }
-        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
+        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, resolutionDiagnostics: diagnostics };
         perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);
         if (traceEnabled)
             traceResult(result);
@@ -42481,6 +42495,8 @@ var ts;
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ts.emptyArray,
             features: NodeResolutionFeatures.None,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: ts.noop
         };
         return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
@@ -43132,6 +43148,7 @@ var ts;
         if (compilerOptions.noDtsResolution) {
             conditions.pop();
         }
+        var diagnostics = [];
         var state = {
             compilerOptions: compilerOptions,
             host: host,
@@ -43140,9 +43157,11 @@ var ts;
             packageJsonInfoCache: cache,
             features: features,
             conditions: conditions,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
-        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ true); };
             var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
@@ -43315,9 +43334,9 @@ var ts;
         }
     }
     function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
-        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.isDeclarationFileName(candidate)) {
+        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.fileExtensionIsOneOf(candidate, ts.supportedTSExtensionsFlat)) {
             var result = tryFile(candidate, onlyRecordFailures, state);
-            return result !== undefined ? { path: candidate, ext: ts.forEach(ts.supportedDeclarationExtensions, function (e) { return ts.fileExtensionIs(candidate, e) ? e : undefined; }) } : undefined;
+            return result !== undefined ? { path: candidate, ext: ts.tryExtractTSExtension(candidate) } : undefined;
         }
         return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
     }
@@ -43440,6 +43459,8 @@ var ts;
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ["node", "require", "types"],
             features: features,
+            requestContainingDirectory: packageJsonInfo.packageDirectory,
+            reportDiagnostic: ts.noop
         };
         var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, 
         /*onlyRecordFailures*/ false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
@@ -43526,6 +43547,8 @@ var ts;
             packageJsonInfoCache: packageJsonInfoCache,
             features: 0,
             conditions: [],
+            requestContainingDirectory: undefined,
+            reportDiagnostic: ts.noop
         };
         var parts = ts.getPathComponents(fileName);
         parts.pop();
@@ -43817,7 +43840,6 @@ var ts;
     function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
         return loadModuleFromTargetImportOrExport;
         function loadModuleFromTargetImportOrExport(target, subpath, pattern) {
-            var _a, _b;
             if (typeof target === "string") {
                 if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) {
                     if (state.traceEnabled) {
@@ -43854,13 +43876,16 @@ var ts;
                     }
                     return toSearchResult(/*value*/ undefined);
                 }
-                var finalPath = ts.getNormalizedAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                var finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
+                var inputLink = tryLoadInputFileForPath(finalPath, subpath, ts.combinePaths(scope.packageDirectory, "package.json"), isImports);
+                if (inputLink)
+                    return inputLink;
                 return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, /*onlyRecordFailures*/ false, state)));
             }
             else if (typeof target === "object" && target !== null) { // eslint-disable-line no-null/no-null
                 if (!Array.isArray(target)) {
-                    for (var _i = 0, _c = ts.getOwnKeys(target); _i < _c.length; _i++) {
-                        var key = _c[_i];
+                    for (var _i = 0, _a = ts.getOwnKeys(target); _i < _a.length; _i++) {
+                        var key = _a[_i];
                         if (key === "default" || state.conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(state.conditions, key)) {
                             var subTarget = target[key];
                             var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern);
@@ -43878,8 +43903,8 @@ var ts;
                         }
                         return toSearchResult(/*value*/ undefined);
                     }
-                    for (var _d = 0, target_2 = target; _d < target_2.length; _d++) {
-                        var elem = target_2[_d];
+                    for (var _b = 0, target_2 = target; _b < target_2.length; _b++) {
+                        var elem = target_2[_b];
                         var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
                         if (result) {
                             return result;
@@ -43897,6 +43922,128 @@ var ts;
                 trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
             }
             return toSearchResult(/*value*/ undefined);
+            function toAbsolutePath(path) {
+                var _a, _b;
+                if (path === undefined)
+                    return path;
+                return ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames })(ts.getNormalizedAbsolutePath(path, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)));
+            }
+            function combineDirectoryPath(root, dir) {
+                return ts.ensureTrailingDirectorySeparator(ts.combinePaths(root, dir));
+            }
+            function useCaseSensitiveFileNames() {
+                return !state.host.useCaseSensitiveFileNames ? true :
+                    typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames :
+                        state.host.useCaseSensitiveFileNames();
+            }
+            function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports) {
+                var _a, _b, _c, _d;
+                // Replace any references to outputs for files in the program with the input files to support package self-names used with outDir
+                // PROBLEM: We don't know how to calculate the output paths yet, because the "common source directory" we use as the base of the file structure
+                // we reproduce into the output directory is based on the set of input files, which we're still in the process of traversing and resolving!
+                // _Given that_, we have to guess what the base of the output directory is (obviously the user wrote the export map, so has some idea what it is!).
+                // We are going to probe _so many_ possible paths. We limit where we'll do this to try to reduce the possibilities of false positive lookups.
+                if ((extensions === Extensions.TypeScript || extensions === Extensions.JavaScript || extensions === Extensions.Json)
+                    && (state.compilerOptions.declarationDir || state.compilerOptions.outDir)
+                    && finalPath.indexOf("/node_modules/") === -1
+                    && (state.compilerOptions.configFile ? ts.startsWith(toAbsolutePath(state.compilerOptions.configFile.fileName), scope.packageDirectory) : true)) {
+                    // So that all means we'll only try these guesses for files outside `node_modules` in a directory where the `package.json` and `tsconfig.json` are siblings.
+                    // Even with all that, we still don't know if the root of the output file structure will be (relative to the package file)
+                    // `.`, `./src` or any other deeper directory structure. (If project references are used, it's definitely `.` by fiat, so that should be pretty common.)
+                    var getCanonicalFileName = ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames });
+                    var commonSourceDirGuesses = [];
+                    // A `rootDir` compiler option strongly indicates the root location
+                    // A `composite` project is using project references and has it's common src dir set to `.`, so it shouldn't need to check any other locations
+                    if (state.compilerOptions.rootDir || (state.compilerOptions.composite && state.compilerOptions.configFilePath)) {
+                        var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return []; }, ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "", getCanonicalFileName));
+                        commonSourceDirGuesses.push(commonDir);
+                    }
+                    else if (state.requestContainingDirectory) {
+                        // However without either of those set we're in the dark. Let's say you have
+                        //
+                        // ./tools/index.ts
+                        // ./src/index.ts
+                        // ./dist/index.js
+                        // ./package.json <-- references ./dist/index.js
+                        // ./tsconfig.json <-- loads ./src/index.ts
+                        //
+                        // How do we know `./src` is the common src dir, and not `./tools`, given only the `./dist` out dir and `./dist/index.js` filename?
+                        // Answer: We... don't. We know we're looking for an `index.ts` input file, but we have _no clue_ which subfolder it's supposed to be loaded from
+                        // without more context.
+                        // But we do have more context! Just a tiny bit more! We're resolving an import _for some other input file_! And that input file, too
+                        // must be inside the common source directory! So we propagate that tidbit of info all the way to here via state.requestContainingDirectory
+                        var requestingFile_1 = toAbsolutePath(ts.combinePaths(state.requestContainingDirectory, "index.ts"));
+                        // And we can try every folder above the common folder for the request folder and the config/package base directory
+                        // This technically can be wrong - we may load ./src/index.ts when ./src/sub/index.ts was right because we don't
+                        // know if only `./src/sub` files were loaded by the program; but this has the best chance to be right of just about anything
+                        // else we have. And, given that we're about to load `./src/index.ts` because we choose it as likely correct, there will then
+                        // be a file outside of `./src/sub` in the program (the file we resolved to), making us de-facto right. So this fallback lookup
+                        // logic may influence what files are pulled in by self-names, which in turn influences the output path shape, but it's all
+                        // internally consistent so the paths should be stable so long as we prefer the "most general" (meaning: top-most-level directory) possible results first.
+                        var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return [requestingFile_1, toAbsolutePath(packagePath)]; }, ((_d = (_c = state.host).getCurrentDirectory) === null || _d === void 0 ? void 0 : _d.call(_c)) || "", getCanonicalFileName));
+                        commonSourceDirGuesses.push(commonDir);
+                        var fragment = ts.ensureTrailingDirectorySeparator(commonDir);
+                        while (fragment && fragment.length > 1) {
+                            var parts = ts.getPathComponents(fragment);
+                            parts.pop(); // remove a directory
+                            var commonDir_1 = ts.getPathFromPathComponents(parts);
+                            commonSourceDirGuesses.unshift(commonDir_1);
+                            fragment = ts.ensureTrailingDirectorySeparator(commonDir_1);
+                        }
+                    }
+                    if (commonSourceDirGuesses.length > 1) {
+                        state.reportDiagnostic(ts.createCompilerDiagnostic(isImports
+                            ? ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate
+                            : ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, entry === "" ? "." : entry, // replace empty string with `.` - the reverse of the operation done when entries are built - so main entrypoint errors don't look weird
+                        packagePath));
+                    }
+                    for (var _i = 0, commonSourceDirGuesses_1 = commonSourceDirGuesses; _i < commonSourceDirGuesses_1.length; _i++) {
+                        var commonSourceDirGuess = commonSourceDirGuesses_1[_i];
+                        var candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
+                        for (var _e = 0, candidateDirectories_1 = candidateDirectories; _e < candidateDirectories_1.length; _e++) {
+                            var candidateDir = candidateDirectories_1[_e];
+                            if (ts.startsWith(finalPath, candidateDir)) {
+                                // The matched export is looking up something in either the out declaration or js dir, now map the written path back into the source dir and source extension
+                                var pathFragment = finalPath.slice(candidateDir.length + 1); // +1 to also remove directory seperator
+                                var possibleInputBase = ts.combinePaths(commonSourceDirGuess, pathFragment);
+                                var jsAndDtsExtensions = [".mjs" /* Mjs */, ".cjs" /* Cjs */, ".js" /* Js */, ".json" /* Json */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".d.ts" /* Dts */];
+                                for (var _f = 0, jsAndDtsExtensions_1 = jsAndDtsExtensions; _f < jsAndDtsExtensions_1.length; _f++) {
+                                    var ext = jsAndDtsExtensions_1[_f];
+                                    if (ts.fileExtensionIs(possibleInputBase, ext)) {
+                                        var inputExts = ts.getPossibleOriginalInputExtensionForExtension(possibleInputBase);
+                                        for (var _g = 0, inputExts_1 = inputExts; _g < inputExts_1.length; _g++) {
+                                            var possibleExt = inputExts_1[_g];
+                                            var possibleInputWithInputExtension = ts.changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
+                                            if ((extensions === Extensions.TypeScript && ts.hasJSFileExtension(possibleInputWithInputExtension)) ||
+                                                (extensions === Extensions.JavaScript && ts.hasTSFileExtension(possibleInputWithInputExtension))) {
+                                                continue;
+                                            }
+                                            if (state.host.fileExists(possibleInputWithInputExtension)) {
+                                                return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, /*onlyRecordFailures*/ false, state)));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return undefined;
+                function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) {
+                    var _a, _b;
+                    // Config file ouput paths are processed to be relative to the host's current directory, while
+                    // otherwise the paths are resolved relative to the common source dir the compiler puts together
+                    var currentDir = state.compilerOptions.configFile ? ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "" : commonSourceDirGuess;
+                    var candidateDirectories = [];
+                    if (state.compilerOptions.declarationDir) {
+                        candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.declarationDir)));
+                    }
+                    if (state.compilerOptions.outDir && state.compilerOptions.outDir !== state.compilerOptions.declarationDir) {
+                        candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.outDir)));
+                    }
+                    return candidateDirectories;
+                }
+            }
         }
     }
     /* @internal */
@@ -44087,11 +44234,12 @@ var ts;
     function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [] };
         var containingDirectory = ts.getDirectoryPath(containingFile);
+        var diagnostics = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: containingDirectory, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
         // No originalPath because classic resolution doesn't resolve realPath
-        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
             if (resolvedUsingSettings) {
@@ -44134,9 +44282,10 @@ var ts;
             trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
         }
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [] };
+        var diagnostics = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: undefined, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
         var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined);
-        return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations, diagnostics, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
     /**
@@ -58000,7 +58149,8 @@ var ts;
                 if (symbol === globalThisSymbol) {
                     var varsOnly_1 = new ts.Map();
                     members.forEach(function (p) {
-                        if (!(p.flags & 418 /* BlockScoped */)) {
+                        var _a;
+                        if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a = p.declarations) === null || _a === void 0 ? void 0 : _a.length) && ts.every(p.declarations, ts.isAmbientModule))) {
                             varsOnly_1.set(p.escapedName, p);
                         }
                     });
@@ -84851,6 +85001,9 @@ var ts;
                 var validForTypeAssertions = ts.isExclusivelyTypeOnlyImportOrExport(declaration);
                 var override = ts.getResolutionModeOverrideForClause(declaration.assertClause, validForTypeAssertions ? grammarErrorOnNode : undefined);
                 if (validForTypeAssertions && override) {
+                    if (!ts.isNightly()) {
+                        grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next);
+                    }
                     if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
                         return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
                     }
@@ -86191,7 +86344,7 @@ var ts;
             if (ts.isDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
                 var symbol = getSymbolOfNode(node);
-                return getTypeOfSymbol(symbol);
+                return symbol ? getTypeOfSymbol(symbol) : errorType;
             }
             if (isDeclarationNameOrImportPropertyName(node)) {
                 var symbol = getSymbolAtLocation(node);
@@ -108249,34 +108402,44 @@ var ts;
             if (!decl.importClause) {
                 // import "mod" - possibly needed for side effects? (global interface patches, module augmentations, etc)
                 return factory.updateImportDeclaration(decl, 
-                /*decorators*/ undefined, decl.modifiers, decl.importClause, rewriteModuleSpecifier(decl, decl.moduleSpecifier), ts.getResolutionModeOverrideForClause(decl.assertClause) ? decl.assertClause : undefined);
+                /*decorators*/ undefined, decl.modifiers, decl.importClause, rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause));
             }
             // The `importClause` visibility corresponds to the default's visibility.
             var visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : undefined;
             if (!decl.importClause.namedBindings) {
                 // No named bindings (either namespace or list), meaning the import is just default or should be elided
                 return visibleDefaultBinding && factory.updateImportDeclaration(decl, /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, 
-                /*namedBindings*/ undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier), ts.getResolutionModeOverrideForClause(decl.assertClause) ? decl.assertClause : undefined);
+                /*namedBindings*/ undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause));
             }
             if (decl.importClause.namedBindings.kind === 268 /* NamespaceImport */) {
                 // Namespace import (optionally with visible default)
                 var namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : /*namedBindings*/ undefined;
-                return visibleDefaultBinding || namedBindings ? factory.updateImportDeclaration(decl, /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, namedBindings), rewriteModuleSpecifier(decl, decl.moduleSpecifier), ts.getResolutionModeOverrideForClause(decl.assertClause) ? decl.assertClause : undefined) : undefined;
+                return visibleDefaultBinding || namedBindings ? factory.updateImportDeclaration(decl, /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, namedBindings), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)) : undefined;
             }
             // Named imports (optionally with visible default)
             var bindingList = ts.mapDefined(decl.importClause.namedBindings.elements, function (b) { return resolver.isDeclarationVisible(b) ? b : undefined; });
             if ((bindingList && bindingList.length) || visibleDefaultBinding) {
                 return factory.updateImportDeclaration(decl, 
-                /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, bindingList && bindingList.length ? factory.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier), ts.getResolutionModeOverrideForClause(decl.assertClause) ? decl.assertClause : undefined);
+                /*decorators*/ undefined, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, bindingList && bindingList.length ? factory.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause));
             }
             // Augmentation of export depends on import
             if (resolver.isImportRequiredByAugmentation(decl)) {
                 return factory.updateImportDeclaration(decl, 
                 /*decorators*/ undefined, decl.modifiers, 
-                /*importClause*/ undefined, rewriteModuleSpecifier(decl, decl.moduleSpecifier), ts.getResolutionModeOverrideForClause(decl.assertClause) ? decl.assertClause : undefined);
+                /*importClause*/ undefined, rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause));
             }
             // Nothing visible
         }
+        function getResolutionModeOverrideForClauseInNightly(assertClause) {
+            var mode = ts.getResolutionModeOverrideForClause(assertClause);
+            if (mode !== undefined) {
+                if (!ts.isNightly()) {
+                    context.addDiagnostic(ts.createDiagnosticForNode(assertClause, ts.Diagnostics.Resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next));
+                }
+                return assertClause;
+            }
+            return undefined;
+        }
         function transformAndReplaceLatePaintedStatements(statements) {
             // This is a `while` loop because `handleSymbolAccessibilityError` can see additional import aliases marked as visible during
             // error handling which must now be included in the output and themselves checked for errors.
@@ -116105,7 +116268,6 @@ var ts;
         ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer.code,
         ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code,
         ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code,
-        ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body.code,
         ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
         ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
         ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
@@ -116492,6 +116654,40 @@ var ts;
         ts.performance.measure("Program", "beforeProgram", "afterProgram");
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return program;
+        function addResolutionDiagnostics(list) {
+            if (!list)
+                return;
+            for (var _i = 0, list_3 = list; _i < list_3.length; _i++) {
+                var elem = list_3[_i];
+                programDiagnostics.add(elem);
+            }
+        }
+        function pullDiagnosticsFromCache(names, containingFile) {
+            var _a;
+            if (!moduleResolutionCache)
+                return;
+            var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
+            var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
+            var containingDir = ts.getDirectoryPath(containingFileName);
+            var redirectedReference = getRedirectReferenceForResolution(containingFile);
+            var i = 0;
+            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
+                var n = names_4[_i];
+                // mimics logic done in the resolution cache, should be resilient to upgrading it to use `FileReference`s for non-type-reference modal lookups to make it rely on the index in the list less
+                var mode = typeof n === "string" ? getModeForResolutionAtIndex(containingFile, i) : getModeForFileReference(n, containingFileMode);
+                var name = typeof n === "string" ? n : n.fileName;
+                i++;
+                // only nonrelative names hit the cache, and, at least as of right now, only nonrelative names can issue diagnostics
+                // (Since diagnostics are only issued via import or export map lookup)
+                // This may totally change if/when the issue of output paths not mapping to input files is fixed in a broader context
+                // When it is, how we extract diagnostics from the module name resolver will have the be refined - the current cache
+                // APIs wrapping the underlying resolver make it almost impossible to smuggle the diagnostics out in a generalized way
+                if (ts.isExternalModuleNameRelative(name))
+                    continue;
+                var diags = (_a = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) === null || _a === void 0 ? void 0 : _a.resolutionDiagnostics;
+                addResolutionDiagnostics(diags);
+            }
+        }
         function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
             if (!moduleNames.length)
                 return ts.emptyArray;
@@ -116503,6 +116699,7 @@ var ts;
             ts.performance.mark("afterResolveModule");
             ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
+            pullDiagnosticsFromCache(moduleNames, containingFile);
             return result;
         }
         function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) {
@@ -120939,8 +121136,8 @@ var ts;
                 !!redirectedReference;
             var seenNamesInFile = ts.createModeAwareCache();
             var i = 0;
-            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
-                var entry = names_4[_i];
+            for (var _i = 0, names_5 = names; _i < names_5.length; _i++) {
+                var entry = names_5[_i];
                 var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase();
                 // Imports supply a `containingSourceFile` but no `containingSourceFileMode` - it would be redundant
                 // they require calculating the mode for a given import from it's position in the resolution table, since a given
@@ -121550,14 +121747,14 @@ var ts;
             if (options === void 0) { options = {}; }
             var info = getInfo(importingSourceFile.path, host);
             var modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences, options);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, /*packageNameOnly*/ true, options.overrideImportMode); });
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, preferences, /*packageNameOnly*/ true, options.overrideImportMode); });
         }
         moduleSpecifiers_1.getNodeModulesPackageName = getNodeModulesPackageName;
         function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, preferences, userPreferences, options) {
             if (options === void 0) { options = {}; }
             var info = getInfo(importingSourceFileName, host);
             var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences, options);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, /*packageNameOnly*/ undefined, options.overrideImportMode); }) ||
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, /*packageNameOnly*/ undefined, options.overrideImportMode); }) ||
                 getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
         }
         function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences, options) {
@@ -121633,7 +121830,7 @@ var ts;
             var relativeSpecifiers;
             for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) {
                 var modulePath = modulePaths_1[_i];
-                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, /*packageNameOnly*/ undefined, options.overrideImportMode);
+                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, /*packageNameOnly*/ undefined, options.overrideImportMode);
                 nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier);
                 if (specifier && modulePath.isRedirect) {
                     // If we got a specifier for a redirect, it was a bare package specifier (e.g. "@foo/bar",
@@ -122026,7 +122223,7 @@ var ts;
                 ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
                 : ts.removeFileExtension(relativePath);
         }
-        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, packageNameOnly, overrideMode) {
+        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
             var path = _a.path, isRedirect = _a.isRedirect;
             var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory;
             if (!host.fileExists || !host.readFile) {
@@ -122040,8 +122237,9 @@ var ts;
             var moduleSpecifier = path;
             var isPackageRootPath = false;
             if (!packageNameOnly) {
+                var preferences = getPreferences(host, userPreferences, options, importingSourceFile);
                 var packageRootIndex = parts.packageRootIndex;
-                var moduleFileNameForExtensionless = void 0;
+                var moduleFileName = void 0;
                 while (true) {
                     // If the module could be imported by a directory name, use that directory's name
                     var _c = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _c.moduleFileToTry, packageRootPath = _c.packageRootPath, blockedByExports = _c.blockedByExports, verbatimFromExports = _c.verbatimFromExports;
@@ -122058,12 +122256,12 @@ var ts;
                         isPackageRootPath = true;
                         break;
                     }
-                    if (!moduleFileNameForExtensionless)
-                        moduleFileNameForExtensionless = moduleFileToTry;
+                    if (!moduleFileName)
+                        moduleFileName = moduleFileToTry;
                     // try with next level of directory
                     packageRootIndex = path.indexOf(ts.directorySeparator, packageRootIndex + 1);
                     if (packageRootIndex === -1) {
-                        moduleSpecifier = getExtensionlessFileName(moduleFileNameForExtensionless);
+                        moduleSpecifier = removeExtensionAndIndexPostFix(moduleFileName, preferences.ending, options, host);
                         break;
                     }
                 }
@@ -122121,7 +122319,7 @@ var ts;
                         }
                     }
                     // If the file is the main module, it can be imported by the package name
-                    var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main;
+                    var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js";
                     if (ts.isString(mainFileRelative)) {
                         var mainExportFile = ts.toPath(mainFileRelative, packageRootPath, getCanonicalFileName);
                         if (ts.removeFileExtension(mainExportFile) === ts.removeFileExtension(getCanonicalFileName(moduleFileToTry))) {
@@ -122129,17 +122327,14 @@ var ts;
                         }
                     }
                 }
-                return { moduleFileToTry: moduleFileToTry };
-            }
-            function getExtensionlessFileName(path) {
-                // We still have a file name - remove the extension
-                var fullModulePathWithoutExtension = ts.removeFileExtension(path);
-                // If the file is /index, it can be imported by its directory name
-                // IFF there is not _also_ a file by the same name
-                if (getCanonicalFileName(fullModulePathWithoutExtension.substring(parts.fileNameIndex)) === "/index" && !tryGetAnyFileFromPath(host, fullModulePathWithoutExtension.substring(0, parts.fileNameIndex))) {
-                    return fullModulePathWithoutExtension.substring(0, parts.fileNameIndex);
+                else {
+                    // No package.json exists; an index.js will still resolve as the package name
+                    var fileName = getCanonicalFileName(moduleFileToTry.substring(parts.packageRootIndex + 1));
+                    if (fileName === "index.d.ts" || fileName === "index.js" || fileName === "index.ts" || fileName === "index.tsx") {
+                        return { moduleFileToTry: moduleFileToTry, packageRootPath: packageRootPath };
+                    }
                 }
-                return fullModulePathWithoutExtension;
+                return { moduleFileToTry: moduleFileToTry };
             }
         }
         function tryGetAnyFileFromPath(host, path) {
@@ -122161,7 +122356,7 @@ var ts;
                 return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
         }
-        function removeExtensionAndIndexPostFix(fileName, ending, options) {
+        function removeExtensionAndIndexPostFix(fileName, ending, options, host) {
             if (ts.fileExtensionIsOneOf(fileName, [".json" /* Json */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]))
                 return fileName;
             var noExtension = ts.removeFileExtension(fileName);
@@ -122169,7 +122364,13 @@ var ts;
                 return noExtension + getJSExtensionForFile(fileName, options);
             switch (ending) {
                 case 0 /* Minimal */:
-                    return ts.removeSuffix(noExtension, "/index");
+                    var withoutIndex = ts.removeSuffix(noExtension, "/index");
+                    if (host && withoutIndex !== noExtension && tryGetAnyFileFromPath(host, withoutIndex)) {
+                        // Can't remove index if there's a file by the same name as the directory.
+                        // Probably more callers should pass `host` so we can determine this?
+                        return noExtension;
+                    }
+                    return withoutIndex;
                 case 1 /* Index */:
                     return noExtension;
                 case 2 /* JsExtension */:
@@ -128975,23 +129176,30 @@ var ts;
         (_d = host.log) === null || _d === void 0 ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results");
         var compilerOptions = program.getCompilerOptions();
         var moduleCount = 0;
-        forEachExternalModuleToImportFrom(program, host, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
-            if (++moduleCount % 100 === 0)
-                cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancellationRequested();
-            var seenExports = new ts.Map();
-            var checker = program.getTypeChecker();
-            var defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
-            // Note: I think we shouldn't actually see resolved module symbols here, but weird merges
-            // can cause it to happen: see 'completionsImport_mergedReExport.ts'
-            if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
-                cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, checker);
-            }
-            checker.forEachExportAndPropertyOfModule(moduleSymbol, function (exported, key) {
-                if (exported !== (defaultInfo === null || defaultInfo === void 0 ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && ts.addToSeen(seenExports, key)) {
-                    cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* Named */, isFromPackageJson, checker);
+        try {
+            forEachExternalModuleToImportFrom(program, host, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
+                if (++moduleCount % 100 === 0)
+                    cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancellationRequested();
+                var seenExports = new ts.Map();
+                var checker = program.getTypeChecker();
+                var defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
+                // Note: I think we shouldn't actually see resolved module symbols here, but weird merges
+                // can cause it to happen: see 'completionsImport_mergedReExport.ts'
+                if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
+                    cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, checker);
                 }
+                checker.forEachExportAndPropertyOfModule(moduleSymbol, function (exported, key) {
+                    if (exported !== (defaultInfo === null || defaultInfo === void 0 ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && ts.addToSeen(seenExports, key)) {
+                        cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* Named */, isFromPackageJson, checker);
+                    }
+                });
             });
-        });
+        }
+        catch (err) {
+            // Ensure cache is reset if operation is cancelled
+            cache.clear();
+            throw err;
+        }
         (_e = host.log) === null || _e === void 0 ? void 0 : _e.call(host, "getExportInfoMap: done in " + (ts.timestamp() - start) + " ms");
         return cache;
     }
@@ -131180,7 +131388,7 @@ var ts;
             KeywordCompletionFilters[KeywordCompletionFilters["TypeAssertionKeywords"] = 6] = "TypeAssertionKeywords";
             KeywordCompletionFilters[KeywordCompletionFilters["TypeKeywords"] = 7] = "TypeKeywords";
             KeywordCompletionFilters[KeywordCompletionFilters["TypeKeyword"] = 8] = "TypeKeyword";
-            KeywordCompletionFilters[KeywordCompletionFilters["Last"] = 7] = "Last";
+            KeywordCompletionFilters[KeywordCompletionFilters["Last"] = 8] = "Last";
         })(KeywordCompletionFilters || (KeywordCompletionFilters = {}));
         var GlobalsSearch;
         (function (GlobalsSearch) {
@@ -131430,7 +131638,7 @@ var ts;
                 var entryNames_1 = new ts.Set(entries.map(function (e) { return e.name; }));
                 for (var _i = 0, _a = getKeywordCompletions(keywordFilters, !insideJsDocTagTypeExpression && ts.isSourceFileJS(sourceFile)); _i < _a.length; _i++) {
                     var keywordEntry = _a[_i];
-                    if (!entryNames_1.has(keywordEntry.name)) {
+                    if (isTypeOnlyLocation && ts.isTypeKeyword(ts.stringToToken(keywordEntry.name)) || !entryNames_1.has(keywordEntry.name)) {
                         ts.insertSorted(entries, keywordEntry, compareCompletionEntries, /*allowDuplicates*/ true);
                     }
                 }
@@ -134149,7 +134357,7 @@ var ts;
         function getKeywordCompletions(keywordFilter, filterOutTsOnlyKeywords) {
             if (!filterOutTsOnlyKeywords)
                 return getTypescriptKeywordCompletions(keywordFilter);
-            var index = keywordFilter + 7 /* Last */ + 1;
+            var index = keywordFilter + 8 /* Last */ + 1;
             return _keywordCompletions[index] ||
                 (_keywordCompletions[index] = getTypescriptKeywordCompletions(keywordFilter)
                     .filter(function (entry) { return !isTypeScriptOnlyKeyword(ts.stringToToken(entry.name)); }));
@@ -146574,6 +146782,9 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    if (ts.nodeIsMissing(child)) {
+                        return inheritedIndentation;
+                    }
                     var childStartPos = child.getStart(sourceFile);
                     var childStartLine = sourceFile.getLineAndCharacterOfPosition(childStartPos).line;
                     var undecoratedChildStartLine = childStartLine;
@@ -174412,10 +174623,11 @@ var ts;
             var outputs = [];
             combineProjectOutputWorker(projects, defaultProject, initialLocation, 
             /*isForRename*/ false, function (project, location, getMappedLocation) {
+                var _a, _b;
                 logger.info("Finding references to " + location.fileName + " position " + location.pos + " in project " + project.getProjectName());
                 var projectOutputs = project.getLanguageService().findReferences(location.fileName, location.pos);
                 if (projectOutputs) {
-                    var clearIsDefinition = projectOutputs[0].references[0].isDefinition === undefined;
+                    var clearIsDefinition = ((_b = (_a = projectOutputs[0]) === null || _a === void 0 ? void 0 : _a.references[0]) === null || _b === void 0 ? void 0 : _b.isDefinition) === undefined;
                     var _loop_9 = function (referencedSymbol) {
                         var mappedDefinitionFile = getMappedLocation(project, documentSpanLocation(referencedSymbol.definition));
                         var definition = mappedDefinitionFile === undefined ?
@@ -174425,8 +174637,8 @@ var ts;
                             symbolToAddTo = { definition: definition, references: [] };
                             outputs.push(symbolToAddTo);
                         }
-                        for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
-                            var ref = _b[_a];
+                        for (var _c = 0, _d = referencedSymbol.references; _c < _d.length; _c++) {
+                            var ref = _d[_c];
                             // If it's in a mapped file, that is added to the todo list by `getMappedLocation`.
                             if (!ts.contains(symbolToAddTo.references, ref, ts.documentSpansEqual) && !getMappedLocation(project, documentSpanLocation(ref))) {
                                 if (clearIsDefinition) {