@typescript-deploys/pr-build 4.7.0-pr-48784-4 → 4.7.0-pr-48784-10

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // 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-insiders.20220427";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220429";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8282,7 +8282,7 @@ var ts;
         Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
         Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
-        Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
+        This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326", "This use of 'import' is invalid. 'import()' calls can be written, but they must have parentheses and cannot have type arguments."),
         String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
         Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts.DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."),
         _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts.DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"),
@@ -8669,7 +8669,6 @@ var ts;
         A_rest_element_cannot_have_a_property_name: diag(2566, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."),
         Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, ts.DiagnosticCategory.Error, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."),
         Property_0_may_not_exist_on_type_1_Did_you_mean_2: diag(2568, ts.DiagnosticCategory.Error, "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568", "Property '{0}' may not exist on type '{1}'. Did you mean '{2}'?"),
-        Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators: diag(2569, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterati_2569", "Type '{0}' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators."),
         Could_not_find_name_0_Did_you_mean_1: diag(2570, ts.DiagnosticCategory.Error, "Could_not_find_name_0_Did_you_mean_1_2570", "Could not find name '{0}'. Did you mean '{1}'?"),
         Object_is_of_type_unknown: diag(2571, ts.DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."),
         A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."),
@@ -9357,6 +9356,7 @@ var ts;
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6397, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6397", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."),
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6398, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_re_6398", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was not resolved."),
         Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_are_not_emitted: diag(6399, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_are_not_emitted_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes are not emitted"),
+        Project_0_is_up_to_date_but_needs_update_to_timestamps_of_output_files_that_are_older_than_input_files: diag(6400, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_but_needs_update_to_timestamps_of_output_files_that_are_older_than_input_fil_6400", "Project '{0}' is up to date but needs update to timestamps of output files that are older than input files"),
         The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
         The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
         The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
@@ -82757,7 +82757,7 @@ var ts;
                 }
                 var yieldType = getIterationTypeOfIterable(use, 0 /* Yield */, inputType, /*errorNode*/ undefined);
                 if (yieldType) {
-                    return [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false];
+                    return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, false];
                 }
                 if (isES2015OrLaterIterable((_a = inputType.symbol) === null || _a === void 0 ? void 0 : _a.escapedName)) {
                     return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, true];
@@ -86034,7 +86034,7 @@ var ts;
                         var symbol = getIntrinsicTagSymbol(name.parent);
                         return symbol === unknownSymbol ? undefined : symbol;
                     }
-                    var result = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ !isJSDoc_1, ts.getHostSignatureFromJSDoc(name));
+                    var result = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /* dontResolveAlias */ true, ts.getHostSignatureFromJSDoc(name));
                     if (!result && isJSDoc_1) {
                         var container = ts.findAncestor(name, ts.or(ts.isClassLike, ts.isInterfaceDeclaration));
                         if (container) {
@@ -87891,6 +87891,9 @@ var ts;
             return ts.some(types, checkGrammarExpressionWithTypeArguments);
         }
         function checkGrammarExpressionWithTypeArguments(node) {
+            if (ts.isExpressionWithTypeArguments(node) && ts.isImportKeyword(node.expression) && node.typeArguments) {
+                return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
+            }
             return checkGrammarTypeArguments(node, node.typeArguments);
         }
         function checkGrammarClassDeclarationHeritageClauses(node) {
@@ -88832,7 +88835,7 @@ var ts;
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext);
             }
             if (node.typeArguments) {
-                return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
+                return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
             }
             var nodeArguments = node.arguments;
             if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext) {
@@ -108628,6 +108631,8 @@ var ts;
                         var varDecl = factory.createVariableDeclaration(newId, /*exclamationToken*/ undefined, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), /*initializer*/ undefined);
                         errorFallbackNode = undefined;
                         var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(135 /* DeclareKeyword */)] : [], factory.createVariableDeclarationList([varDecl], 2 /* Const */));
+                        preserveJsDoc(statement, input);
+                        ts.removeAllComments(input);
                         return [statement, factory.updateExportAssignment(input, input.decorators, input.modifiers, newId)];
                     }
                 }
@@ -120122,6 +120127,10 @@ var ts;
         }
         return ts.filterSemanticDiagnostics(diagnostics, state.compilerOptions);
     }
+    function isProgramBundleEmitBuildInfo(info) {
+        return !!ts.outFile(info.options || {});
+    }
+    ts.isProgramBundleEmitBuildInfo = isProgramBundleEmitBuildInfo;
     /**
      * Gets the program information to be emitted in buildInfo so that we can use it to create new program
      */
@@ -120133,7 +120142,18 @@ var ts;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
         state.dtsChangeTime = state.hasChangedEmitSignature ? ts.getCurrentTime(host).getTime() : state.dtsChangeTime;
         if (outFilePath) {
+            var fileNames_1 = [];
+            var fileInfos_1 = [];
+            state.program.getRootFileNames().forEach(function (f) {
+                var sourceFile = state.program.getSourceFile(f);
+                if (!sourceFile)
+                    return;
+                fileNames_1.push(relativeToBuildInfo(sourceFile.resolvedPath));
+                fileInfos_1.push(sourceFile.version);
+            });
             var result_15 = {
+                fileNames: fileNames_1,
+                fileInfos: fileInfos_1,
                 options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
                 outSignature: state.outSignature,
                 dtsChangeTime: state.dtsChangeTime,
@@ -120660,43 +120680,54 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
-    function createBuilderProgramUsingProgramBuildInfo(programFromBuildInfo, buildInfoPath, host) {
-        var _a, _b, _c, _d, _e;
+    function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
+        var _a, _b, _c, _d;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
-        var program = programFromBuildInfo;
-        var filePaths = (_a = program.fileNames) === null || _a === void 0 ? void 0 : _a.map(toPath);
-        var filePathsSetList = (_b = program.fileIdsList) === null || _b === void 0 ? void 0 : _b.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
-        var fileInfos = new ts.Map();
-        var emitSignatures = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
-        (_d = program.fileInfos) === null || _d === void 0 ? void 0 : _d.forEach(function (fileInfo, index) {
-            var path = toFilePath(index + 1);
-            var stateFileInfo = toBuilderStateFileInfo(fileInfo);
-            fileInfos.set(path, stateFileInfo);
-            if (emitSignatures && stateFileInfo.signature)
-                emitSignatures.set(path, stateFileInfo.signature);
-        });
-        (_e = program.emitSignatures) === null || _e === void 0 ? void 0 : _e.forEach(function (value) {
-            if (ts.isNumber(value))
-                emitSignatures.delete(toFilePath(value));
-            else
-                emitSignatures.set(toFilePath(value[0]), value[1]);
-        });
-        var state = {
-            fileInfos: fileInfos,
-            compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
-            referencedMap: toManyToManyPathMap(program.referencedMap),
-            exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
-            semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }),
-            hasReusableDiagnostic: true,
-            affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
-            affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
-            affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
-            changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
-            dtsChangeTime: program.dtsChangeTime,
-            emitSignatures: (emitSignatures === null || emitSignatures === void 0 ? void 0 : emitSignatures.size) ? emitSignatures : undefined,
-            outSignature: program.outSignature,
-        };
+        var state;
+        var filePaths;
+        var filePathsSetList;
+        if (isProgramBundleEmitBuildInfo(program)) {
+            state = {
+                fileInfos: new ts.Map(),
+                compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
+                dtsChangeTime: program.dtsChangeTime,
+                outSignature: program.outSignature,
+            };
+        }
+        else {
+            filePaths = (_a = program.fileNames) === null || _a === void 0 ? void 0 : _a.map(toPath);
+            filePathsSetList = (_b = program.fileIdsList) === null || _b === void 0 ? void 0 : _b.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
+            var fileInfos_2 = new ts.Map();
+            var emitSignatures_1 = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
+            program.fileInfos.forEach(function (fileInfo, index) {
+                var path = toFilePath(index + 1);
+                var stateFileInfo = toBuilderStateFileInfo(fileInfo);
+                fileInfos_2.set(path, stateFileInfo);
+                if (emitSignatures_1 && stateFileInfo.signature)
+                    emitSignatures_1.set(path, stateFileInfo.signature);
+            });
+            (_d = program.emitSignatures) === null || _d === void 0 ? void 0 : _d.forEach(function (value) {
+                if (ts.isNumber(value))
+                    emitSignatures_1.delete(toFilePath(value));
+                else
+                    emitSignatures_1.set(toFilePath(value[0]), value[1]);
+            });
+            state = {
+                fileInfos: fileInfos_2,
+                compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
+                referencedMap: toManyToManyPathMap(program.referencedMap),
+                exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
+                semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }),
+                hasReusableDiagnostic: true,
+                affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
+                affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
+                affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
+                changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
+                dtsChangeTime: program.dtsChangeTime,
+                emitSignatures: (emitSignatures_1 === null || emitSignatures_1 === void 0 ? void 0 : emitSignatures_1.size) ? emitSignatures_1 : undefined,
+            };
+        }
         return {
             getState: function () { return state; },
             backupEmitState: ts.noop,
@@ -120746,6 +120777,18 @@ var ts;
         }
     }
     ts.createBuilderProgramUsingProgramBuildInfo = createBuilderProgramUsingProgramBuildInfo;
+    function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
+        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
+        var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
+        var fileInfos = new ts.Map();
+        program.fileInfos.forEach(function (fileInfo, index) {
+            var path = ts.toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName);
+            var version = ts.isString(fileInfo) ? fileInfo : fileInfo.version; // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
+            fileInfos.set(path, version);
+        });
+        return fileInfos;
+    }
+    ts.getBuildInfoFileVersionMap = getBuildInfoFileVersionMap;
     function createRedirectedBuilderProgram(getState, configFileParsingDiagnostics) {
         return {
             getState: ts.notImplemented,
@@ -123680,11 +123723,12 @@ var ts;
         UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 9] = "UpstreamBlocked";
         UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 10] = "ComputingUpstream";
         UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 11] = "TsVersionOutputOfDate";
+        UpToDateStatusType[UpToDateStatusType["UpToDateWithInputFileText"] = 12] = "UpToDateWithInputFileText";
         /**
          * Projects with no outputs (i.e. "solution" files)
          */
-        UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 12] = "ContainerOnly";
-        UpToDateStatusType[UpToDateStatusType["ForceBuild"] = 13] = "ForceBuild";
+        UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 13] = "ContainerOnly";
+        UpToDateStatusType[UpToDateStatusType["ForceBuild"] = 14] = "ForceBuild";
     })(UpToDateStatusType = ts.UpToDateStatusType || (ts.UpToDateStatusType = {}));
     function resolveConfigFileProjectName(project) {
         if (ts.fileExtensionIs(project, ".json" /* Json */)) {
@@ -124511,7 +124555,7 @@ var ts;
                     }
                     continue;
                 }
-                if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
+                if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes || status.type === ts.UpToDateStatusType.UpToDateWithInputFileText) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder);
                 }
@@ -124725,6 +124769,8 @@ var ts;
         var oldestOutputFileName = "(none)";
         var oldestOutputFileTime = maximumDate;
         var buildInfoTime;
+        var buildInfoProgram;
+        var buildInfoVersionMap;
         var newestDeclarationFileContentChangedTime;
         if (buildInfoPath) {
             var buildInfoCacheEntry_1 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
@@ -124757,6 +124803,7 @@ var ts;
                         buildInfoFile: buildInfoPath
                     };
                 }
+                buildInfoProgram = buildInfo.program;
             }
             oldestOutputFileTime = buildInfoTime;
             oldestOutputFileName = buildInfoPath;
@@ -124765,6 +124812,7 @@ var ts;
         // Check input files
         var newestInputFileName = undefined;
         var newestInputFileTime = minimumDate;
+        var pseudoInputUptodate = false;
         // Get timestamps of input files
         for (var _e = 0, _f = project.fileNames; _e < _f.length; _e++) {
             var inputFile = _f[_e];
@@ -124777,11 +124825,25 @@ var ts;
             }
             // If an buildInfo is older than the newest input, we can stop checking
             if (buildInfoTime && buildInfoTime < inputTime) {
-                return {
-                    type: ts.UpToDateStatusType.OutOfDateWithSelf,
-                    outOfDateOutputFileName: buildInfoPath,
-                    newerInputFileName: inputFile
-                };
+                var version_3 = void 0;
+                var currentVersion = void 0;
+                if (buildInfoProgram) {
+                    // Read files and see if they are same, read is anyways cached
+                    if (!buildInfoVersionMap)
+                        buildInfoVersionMap = ts.getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host);
+                    version_3 = buildInfoVersionMap.get(toPath(state, inputFile));
+                    var text = version_3 ? state.readFileWithCache(inputFile) : undefined;
+                    currentVersion = text && (host.createHash || ts.generateDjb2Hash)(text);
+                    if (version_3 && version_3 === currentVersion)
+                        pseudoInputUptodate = true;
+                }
+                if (!version_3 || version_3 !== currentVersion) {
+                    return {
+                        type: ts.UpToDateStatusType.OutOfDateWithSelf,
+                        outOfDateOutputFileName: buildInfoPath,
+                        newerInputFileName: inputFile
+                    };
+                }
             }
             if (inputTime > newestInputFileTime) {
                 newestInputFileName = inputFile;
@@ -124886,7 +124948,11 @@ var ts;
         }
         // Up to date
         return {
-            type: pseudoUpToDate ? ts.UpToDateStatusType.UpToDateWithUpstreamTypes : ts.UpToDateStatusType.UpToDate,
+            type: pseudoUpToDate ?
+                ts.UpToDateStatusType.UpToDateWithUpstreamTypes :
+                pseudoInputUptodate ?
+                    ts.UpToDateStatusType.UpToDateWithInputFileText :
+                    ts.UpToDateStatusType.UpToDate,
             newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTime,
             newestInputFileTime: newestInputFileTime,
             newestInputFileName: newestInputFileName,
@@ -125029,6 +125095,7 @@ var ts;
                                 break;
                             }
                         // falls through
+                        case ts.UpToDateStatusType.UpToDateWithInputFileText:
                         case ts.UpToDateStatusType.UpToDateWithUpstreamTypes:
                         case ts.UpToDateStatusType.OutOfDateWithPrepend:
                             if (!(buildResult & BuildResultFlags.DeclarationOutputUnchanged)) {
@@ -125219,7 +125286,7 @@ var ts;
         if (!state.watch || !state.lastCachedPackageJsonLookups)
             return;
         ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath), new ts.Map(state.lastCachedPackageJsonLookups.get(resolvedPath)), {
-            createNewValue: function (path, _input) { return watchFile(state, path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
+            createNewValue: function (path, _input) { return watchFile(state, path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
             onDeleteValue: ts.closeFileWatcher,
         });
     }
@@ -125370,6 +125437,8 @@ var ts;
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relName(state, configFileName), relName(state, status.newerProjectName));
             case ts.UpToDateStatusType.UpToDateWithUpstreamTypes:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, relName(state, configFileName));
+            case ts.UpToDateStatusType.UpToDateWithInputFileText:
+                return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_but_needs_update_to_timestamps_of_output_files_that_are_older_than_input_files, relName(state, configFileName));
             case ts.UpToDateStatusType.UpstreamOutOfDate:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date, relName(state, configFileName), relName(state, status.upstreamProjectName));
             case ts.UpToDateStatusType.UpstreamBlocked:
@@ -125548,6 +125617,17 @@ var ts;
         SymbolDisplayPartKind[SymbolDisplayPartKind["linkName"] = 23] = "linkName";
         SymbolDisplayPartKind[SymbolDisplayPartKind["linkText"] = 24] = "linkText";
     })(SymbolDisplayPartKind = ts.SymbolDisplayPartKind || (ts.SymbolDisplayPartKind = {}));
+    // Do not change existing values, as they exist in telemetry.
+    var CompletionInfoFlags;
+    (function (CompletionInfoFlags) {
+        CompletionInfoFlags[CompletionInfoFlags["None"] = 0] = "None";
+        CompletionInfoFlags[CompletionInfoFlags["MayIncludeAutoImports"] = 1] = "MayIncludeAutoImports";
+        CompletionInfoFlags[CompletionInfoFlags["IsImportStatementCompletion"] = 2] = "IsImportStatementCompletion";
+        CompletionInfoFlags[CompletionInfoFlags["IsContinuation"] = 4] = "IsContinuation";
+        CompletionInfoFlags[CompletionInfoFlags["ResolvedModuleSpecifiers"] = 8] = "ResolvedModuleSpecifiers";
+        CompletionInfoFlags[CompletionInfoFlags["ResolvedModuleSpecifiersBeyondLimit"] = 16] = "ResolvedModuleSpecifiersBeyondLimit";
+        CompletionInfoFlags[CompletionInfoFlags["MayIncludeMethodSnippets"] = 32] = "MayIncludeMethodSnippets";
+    })(CompletionInfoFlags = ts.CompletionInfoFlags || (ts.CompletionInfoFlags = {}));
     var OutliningSpanKind;
     (function (OutliningSpanKind) {
         /** Single or multi-line comments */
@@ -127560,6 +127640,14 @@ var ts;
         return __assign(__assign({}, createModuleSpecifierResolutionHost(program, host)), { getCommonSourceDirectory: function () { return program.getCommonSourceDirectory(); } });
     }
     ts.getModuleSpecifierResolverHost = getModuleSpecifierResolverHost;
+    function moduleResolutionRespectsExports(moduleResolution) {
+        return moduleResolution >= ts.ModuleResolutionKind.Node12 && moduleResolution <= ts.ModuleResolutionKind.NodeNext;
+    }
+    ts.moduleResolutionRespectsExports = moduleResolutionRespectsExports;
+    function moduleResolutionUsesNodeModules(moduleResolution) {
+        return moduleResolution === ts.ModuleResolutionKind.NodeJs || moduleResolution >= ts.ModuleResolutionKind.Node12 && moduleResolution <= ts.ModuleResolutionKind.NodeNext;
+    }
+    ts.moduleResolutionUsesNodeModules = moduleResolutionUsesNodeModules;
     function makeImportIfNecessary(defaultImport, namedImports, moduleSpecifier, quotePreference) {
         return defaultImport || namedImports && namedImports.length ? makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference) : undefined;
     }
@@ -129163,8 +129251,8 @@ var ts;
         if (from === to)
             return false;
         var cachedResult = moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.get(from.path, to.path, preferences, {});
-        if ((cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.isAutoImportable) !== undefined) {
-            return cachedResult.isAutoImportable;
+        if ((cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.isBlockedByPackageJsonDependencies) !== undefined) {
+            return !cachedResult.isBlockedByPackageJsonDependencies;
         }
         var getCanonicalFileName = ts.hostGetCanonicalFileName(moduleSpecifierResolutionHost);
         var globalTypingsCache = (_a = moduleSpecifierResolutionHost.getGlobalTypingsCacheLocation) === null || _a === void 0 ? void 0 : _a.call(moduleSpecifierResolutionHost);
@@ -129178,7 +129266,7 @@ var ts;
         });
         if (packageJsonFilter) {
             var isAutoImportable = hasImportablePath && packageJsonFilter.allowsImportingSourceFile(to, moduleSpecifierResolutionHost);
-            moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.setIsAutoImportable(from.path, to.path, preferences, {}, isAutoImportable);
+            moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.setBlockedByPackageJsonDependencies(from.path, to.path, preferences, {}, !isAutoImportable);
             return isAutoImportable;
         }
         return hasImportablePath;
@@ -131457,15 +131545,26 @@ var ts;
             var _a, _b, _c;
             var start = ts.timestamp();
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
-            var resolutionLimitExceeded = false;
+            // Under `--moduleResolution nodenext`, we have to resolve module specifiers up front, because
+            // package.json exports can mean we *can't* resolve a module specifier (that doesn't include a
+            // relative path into node_modules), and we want to filter those completions out entirely.
+            // Import statement completions always need specifier resolution because the module specifier is
+            // part of their `insertText`, not the `codeActions` creating edits away from the cursor.
+            var needsFullResolution = isForImportStatementCompletion || ts.moduleResolutionRespectsExports(ts.getEmitModuleResolutionKind(program.getCompilerOptions()));
+            var skippedAny = false;
             var ambientCount = 0;
             var resolvedCount = 0;
             var resolvedFromCacheCount = 0;
             var cacheAttemptCount = 0;
-            var result = cb({ tryResolve: tryResolve, resolutionLimitExceeded: function () { return resolutionLimitExceeded; } });
+            var result = cb({
+                tryResolve: tryResolve,
+                skippedAny: function () { return skippedAny; },
+                resolvedAny: function () { return resolvedCount > 0; },
+                resolvedBeyondLimit: function () { return resolvedCount > Completions.moduleSpecifierResolutionLimit; },
+            });
             var hitRateMessage = cacheAttemptCount ? " (" + (resolvedFromCacheCount / cacheAttemptCount * 100).toFixed(1) + "% hit rate)" : "";
             (_a = host.log) === null || _a === void 0 ? void 0 : _a.call(host, logPrefix + ": resolved " + resolvedCount + " module specifiers, plus " + ambientCount + " ambient and " + resolvedFromCacheCount + " from cache" + hitRateMessage);
-            (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, logPrefix + ": response is " + (resolutionLimitExceeded ? "incomplete" : "complete"));
+            (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, logPrefix + ": response is " + (skippedAny ? "incomplete" : "complete"));
             (_c = host.log) === null || _c === void 0 ? void 0 : _c.call(host, logPrefix + ": " + (ts.timestamp() - start));
             return result;
             function tryResolve(exportInfo, symbolName, isFromAmbientModule) {
@@ -131474,22 +131573,22 @@ var ts;
                     if (result_1) {
                         ambientCount++;
                     }
-                    return result_1;
+                    return result_1 || "failed";
                 }
-                var shouldResolveModuleSpecifier = isForImportStatementCompletion || preferences.allowIncompleteCompletions && resolvedCount < Completions.moduleSpecifierResolutionLimit;
+                var shouldResolveModuleSpecifier = needsFullResolution || preferences.allowIncompleteCompletions && resolvedCount < Completions.moduleSpecifierResolutionLimit;
                 var shouldGetModuleSpecifierFromCache = !shouldResolveModuleSpecifier && preferences.allowIncompleteCompletions && cacheAttemptCount < Completions.moduleSpecifierResolutionCacheAttemptLimit;
                 var result = (shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache)
                     ? ts.codefix.getModuleSpecifierForBestExportInfo(exportInfo, symbolName, position, isValidTypeOnlyUseSite, sourceFile, program, host, preferences, packageJsonImportFilter, shouldGetModuleSpecifierFromCache)
                     : undefined;
                 if (!shouldResolveModuleSpecifier && !shouldGetModuleSpecifierFromCache || shouldGetModuleSpecifierFromCache && !result) {
-                    resolutionLimitExceeded = true;
+                    skippedAny = true;
                 }
                 resolvedCount += (result === null || result === void 0 ? void 0 : result.computedWithoutCacheCount) || 0;
-                resolvedFromCacheCount += exportInfo.length - resolvedCount;
+                resolvedFromCacheCount += exportInfo.length - ((result === null || result === void 0 ? void 0 : result.computedWithoutCacheCount) || 0);
                 if (shouldGetModuleSpecifierFromCache) {
                     cacheAttemptCount++;
                 }
-                return result;
+                return result || (needsFullResolution ? "failed" : "skipped");
             }
         }
         function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext) {
@@ -131587,6 +131686,7 @@ var ts;
             var newEntries = resolvingModuleSpecifiers("continuePreviousIncompleteResponse", host, program, file, location.getStart(), preferences, 
             /*isForImportStatementCompletion*/ false, ts.isValidTypeOnlyAliasUseSite(location), function (context) {
                 var entries = ts.mapDefined(previousResponse.entries, function (entry) {
+                    var _a;
                     if (!entry.hasAction || !entry.source || !entry.data || completionEntryDataIsResolved(entry.data)) {
                         // Not an auto import or already resolved; keep as is
                         return entry;
@@ -131598,8 +131698,12 @@ var ts;
                     var origin = ts.Debug.checkDefined(getAutoImportSymbolFromCompletionEntryData(entry.name, entry.data, program, host)).origin;
                     var info = exportMap.get(file.path, entry.data.exportMapKey);
                     var result = info && context.tryResolve(info, entry.name, !ts.isExternalModuleNameRelative(ts.stripQuotes(origin.moduleSymbol.name)));
-                    if (!result)
+                    if (result === "skipped")
                         return entry;
+                    if (!result || result === "failed") {
+                        (_a = host.log) === null || _a === void 0 ? void 0 : _a.call(host, "Unexpected failure resolving auto import for '" + entry.name + "' from '" + entry.source + "'");
+                        return undefined;
+                    }
                     var newOrigin = __assign(__assign({}, origin), { kind: 32 /* ResolvedExport */, moduleSpecifier: result.moduleSpecifier });
                     // Mutating for performance... feels sketchy but nobody else uses the cache,
                     // so why bother allocating a bunch of new objects?
@@ -131608,12 +131712,13 @@ var ts;
                     entry.sourceDisplay = [ts.textPart(newOrigin.moduleSpecifier)];
                     return entry;
                 });
-                if (!context.resolutionLimitExceeded()) {
+                if (!context.skippedAny()) {
                     previousResponse.isIncomplete = undefined;
                 }
                 return entries;
             });
             previousResponse.entries = newEntries;
+            previousResponse.flags = (previousResponse.flags || 0) | 4 /* IsContinuation */;
             return previousResponse;
         }
         function jsdocCompletionInfo(entries) {
@@ -131695,12 +131800,13 @@ var ts;
                 ts.insertSorted(entries, createCompletionEntryForLiteral(sourceFile, preferences, literal), compareCompletionEntries, /*allowDuplicates*/ true);
             }
             return {
+                flags: completionData.flags,
                 isGlobalCompletion: isInSnippetScope,
                 isIncomplete: preferences.allowIncompleteCompletions && hasUnresolvedAutoImports ? true : undefined,
                 isMemberCompletion: isMemberCompletionKind(completionKind),
                 isNewIdentifierLocation: isNewIdentifierLocation,
                 optionalReplacementSpan: getOptionalReplacementSpan(location),
-                entries: entries
+                entries: entries,
             };
         }
         function isUncheckedFile(sourceFile, compilerOptions) {
@@ -132757,6 +132863,7 @@ var ts;
             var location = ts.getTouchingPropertyName(sourceFile, position);
             var keywordFilters = 0 /* None */;
             var isNewIdentifierLocation = false;
+            var flags = 0 /* None */;
             if (contextToken) {
                 var importStatementCompletion = getImportStatementCompletionInfo(contextToken);
                 isNewIdentifierLocation = importStatementCompletion.isNewIdentifierLocation;
@@ -132776,6 +132883,7 @@ var ts;
                     // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients
                     // to opt in with the `includeCompletionsForImportStatements` user preference.
                     importCompletionNode = importStatementCompletion.replacementNode;
+                    flags |= 2 /* IsImportStatementCompletion */;
                 }
                 // Bail out if this is a known invalid completion location
                 if (!importCompletionNode && isCompletionListBlocker(contextToken)) {
@@ -132968,6 +133076,7 @@ var ts;
                 isRightOfOpenTag: isRightOfOpenTag,
                 importCompletionNode: importCompletionNode,
                 hasUnresolvedAutoImports: hasUnresolvedAutoImports,
+                flags: flags,
             };
             function isTagWithTypeExpression(tag) {
                 switch (tag.kind) {
@@ -133377,6 +133486,7 @@ var ts;
                     // Asking for completion details for an item that is not an auto-import
                     return;
                 }
+                flags |= 1 /* MayIncludeAutoImports */;
                 // import { type | -> token text should be blank
                 var isAfterTypeOnlyImportSpecifierModifier = previousToken === contextToken
                     && importCompletionNode
@@ -133407,16 +133517,36 @@ var ts;
                             return true;
                         return charactersFuzzyMatchInString(symbolName, lowerCaseTokenText);
                     }, function (info, symbolName, isFromAmbientModule, exportMapKey) {
+                        var _a;
                         if (detailsEntryId && !ts.some(info, function (i) { return detailsEntryId.source === ts.stripQuotes(i.moduleSymbol.name); })) {
                             return;
                         }
-                        var defaultExportInfo = ts.find(info, isImportableExportInfo);
-                        if (!defaultExportInfo) {
+                        // Do a relatively cheap check to bail early if all re-exports are non-importable
+                        // due to file location or package.json dependency filtering. For non-node12+
+                        // module resolution modes, getting past this point guarantees that we'll be
+                        // able to generate a suitable module specifier, so we can safely show a completion,
+                        // even if we defer computing the module specifier.
+                        var firstImportableExportInfo = ts.find(info, isImportableExportInfo);
+                        if (!firstImportableExportInfo) {
+                            return;
+                        }
+                        // In node12+, module specifier resolution can fail due to modules being blocked
+                        // by package.json `exports`. If that happens, don't show a completion item.
+                        // N.B. in this resolution mode we always try to resolve module specifiers here,
+                        // because we have to know now if it's going to fail so we can omit the completion
+                        // from the list.
+                        var result = context.tryResolve(info, symbolName, isFromAmbientModule) || {};
+                        if (result === "failed")
                             return;
+                        // If we skipped resolving module specifiers, our selection of which ExportInfo
+                        // to use here is arbitrary, since the info shown in the completion list derived from
+                        // it should be identical regardless of which one is used. During the subsequent
+                        // `CompletionEntryDetails` request, we'll get all the ExportInfos again and pick
+                        // the best one based on the module specifier it produces.
+                        var exportInfo = firstImportableExportInfo, moduleSpecifier;
+                        if (result !== "skipped") {
+                            (_a = result.exportInfo, exportInfo = _a === void 0 ? firstImportableExportInfo : _a, moduleSpecifier = result.moduleSpecifier);
                         }
-                        // If we don't need to resolve module specifiers, we can use any re-export that is importable at all
-                        // (We need to ensure that at least one is importable to show a completion.)
-                        var _a = context.tryResolve(info, symbolName, isFromAmbientModule) || {}, _b = _a.exportInfo, exportInfo = _b === void 0 ? defaultExportInfo : _b, moduleSpecifier = _a.moduleSpecifier;
                         var isDefaultExport = exportInfo.exportKind === 1 /* Default */;
                         var symbol = isDefaultExport && ts.getLocalSymbolForExportDefault(exportInfo.symbol) || exportInfo.symbol;
                         pushAutoImportSymbol(symbol, {
@@ -133431,7 +133561,9 @@ var ts;
                             isFromPackageJson: exportInfo.isFromPackageJson,
                         });
                     });
-                    hasUnresolvedAutoImports = context.resolutionLimitExceeded();
+                    hasUnresolvedAutoImports = context.skippedAny();
+                    flags |= context.resolvedAny() ? 8 /* ResolvedModuleSpecifiers */ : 0;
+                    flags |= context.resolvedBeyondLimit() ? 16 /* ResolvedModuleSpecifiersBeyondLimit */ : 0;
                 });
                 function isImportableExportInfo(info) {
                     var moduleFile = ts.tryCast(info.moduleSymbol.valueDeclaration, ts.isSourceFile);
@@ -133479,6 +133611,7 @@ var ts;
                         return;
                     }
                     var origin = __assign({ kind: 128 /* ObjectLiteralMethod */ }, entryProps);
+                    flags |= 32 /* MayIncludeMethodSnippets */;
                     symbolToOriginInfoMap[symbols.length] = origin;
                     symbols.push(member);
                 });
@@ -133675,7 +133808,7 @@ var ts;
                     // through type declaration or inference.
                     // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                     // type of parameter will flow in from the contextual type of the function
-                    var canGetType = ts.hasInitializer(rootDeclaration) || ts.hasType(rootDeclaration) || rootDeclaration.parent.parent.kind === 244 /* ForOfStatement */;
+                    var canGetType = ts.hasInitializer(rootDeclaration) || !!ts.getEffectiveTypeAnnotationNode(rootDeclaration) || rootDeclaration.parent.parent.kind === 244 /* ForOfStatement */;
                     if (!canGetType && rootDeclaration.kind === 164 /* Parameter */) {
                         if (ts.isExpression(rootDeclaration.parent)) {
                             canGetType = !!typeChecker.getContextualType(rootDeclaration.parent);
@@ -134950,6 +135083,8 @@ var ts;
                     return highlightSpans(getAsyncAndAwaitOccurrences(node));
                 case 125 /* YieldKeyword */:
                     return highlightSpans(getYieldOccurrences(node));
+                case 101 /* InKeyword */:
+                    return undefined;
                 default:
                     return ts.isModifierKind(node.kind) && (ts.isDeclaration(node.parent) || ts.isVariableStatement(node.parent))
                         ? highlightSpans(getModifierOccurrences(node.kind, node.parent))
@@ -149718,7 +149853,7 @@ var ts;
             ts.Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined.code,
             ts.Diagnostics.Type_0_is_not_an_array_type.code,
             ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type.code,
-            ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators.code,
+            ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher.code,
             ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
             ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
             ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
@@ -152672,6 +152807,7 @@ var ts;
             var compilerOptions = program.getCompilerOptions();
             var moduleSpecifierResolutionHost = ts.createModuleSpecifierResolutionHost(program, host);
             var getChecker = ts.memoizeOne(function (isFromPackageJson) { return isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker(); });
+            var rejectNodeModulesRelativePaths = ts.moduleResolutionUsesNodeModules(ts.getEmitModuleResolutionKind(compilerOptions));
             var getModuleSpecifiers = fromCacheOnly
                 ? function (moduleSymbol) { return ({ moduleSpecifiers: ts.moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }); }
                 : function (moduleSymbol, checker) { return ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences); };
@@ -152682,19 +152818,19 @@ var ts;
                 var importedSymbolHasValueMeaning = !!(exportInfo.targetFlags & 111551 /* Value */);
                 var addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, exportInfo.symbol, exportInfo.targetFlags, checker, compilerOptions);
                 computedWithoutCacheCount += computedWithoutCache ? 1 : 0;
-                return moduleSpecifiers === null || moduleSpecifiers === void 0 ? void 0 : moduleSpecifiers.map(function (moduleSpecifier) {
-                    // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
-                    return !importedSymbolHasValueMeaning && isJs && position !== undefined
-                        ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo, isReExport: i > 0 }
-                        : {
-                            kind: 3 /* AddNew */,
-                            moduleSpecifier: moduleSpecifier,
-                            importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions),
-                            useRequire: useRequire,
-                            addAsTypeOnly: addAsTypeOnly,
-                            exportInfo: exportInfo,
-                            isReExport: i > 0,
-                        };
+                return ts.mapDefined(moduleSpecifiers, function (moduleSpecifier) {
+                    return rejectNodeModulesRelativePaths && ts.pathContainsNodeModules(moduleSpecifier) ? undefined :
+                        // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
+                        !importedSymbolHasValueMeaning && isJs && position !== undefined ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo, isReExport: i > 0 } :
+                            {
+                                kind: 3 /* AddNew */,
+                                moduleSpecifier: moduleSpecifier,
+                                importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions),
+                                useRequire: useRequire,
+                                addAsTypeOnly: addAsTypeOnly,
+                                exportInfo: exportInfo,
+                                isReExport: i > 0,
+                            };
                 });
             });
             return { computedWithoutCacheCount: computedWithoutCacheCount, fixes: fixes };
@@ -174251,7 +174387,7 @@ var ts;
                     return cache.get(toFileName);
                 },
                 set: function (fromFileName, toFileName, preferences, options, modulePaths, moduleSpecifiers) {
-                    ensureCache(fromFileName, preferences, options).set(toFileName, createInfo(modulePaths, moduleSpecifiers, /*isAutoImportable*/ true));
+                    ensureCache(fromFileName, preferences, options).set(toFileName, createInfo(modulePaths, moduleSpecifiers, /*isBlockedByPackageJsonDependencies*/ false));
                     // If any module specifiers were generated based off paths in node_modules,
                     // a package.json file in that package was read and is an input to the cached.
                     // Instead of watching each individual package.json file, set up a wildcard
@@ -174277,17 +174413,17 @@ var ts;
                         info.modulePaths = modulePaths;
                     }
                     else {
-                        cache.set(toFileName, createInfo(modulePaths, /*moduleSpecifiers*/ undefined, /*isAutoImportable*/ undefined));
+                        cache.set(toFileName, createInfo(modulePaths, /*moduleSpecifiers*/ undefined, /*isBlockedByPackageJsonDependencies*/ undefined));
                     }
                 },
-                setIsAutoImportable: function (fromFileName, toFileName, preferences, options, isAutoImportable) {
+                setBlockedByPackageJsonDependencies: function (fromFileName, toFileName, preferences, options, isBlockedByPackageJsonDependencies) {
                     var cache = ensureCache(fromFileName, preferences, options);
                     var info = cache.get(toFileName);
                     if (info) {
-                        info.isAutoImportable = isAutoImportable;
+                        info.isBlockedByPackageJsonDependencies = isBlockedByPackageJsonDependencies;
                     }
                     else {
-                        cache.set(toFileName, createInfo(/*modulePaths*/ undefined, /*moduleSpecifiers*/ undefined, isAutoImportable));
+                        cache.set(toFileName, createInfo(/*modulePaths*/ undefined, /*moduleSpecifiers*/ undefined, isBlockedByPackageJsonDependencies));
                     }
                 },
                 clear: function () {
@@ -174315,8 +174451,8 @@ var ts;
             function key(fromFileName, preferences, options) {
                 return fromFileName + "," + preferences.importModuleSpecifierEnding + "," + preferences.importModuleSpecifierPreference + "," + options.overrideImportMode;
             }
-            function createInfo(modulePaths, moduleSpecifiers, isAutoImportable) {
-                return { modulePaths: modulePaths, moduleSpecifiers: moduleSpecifiers, isAutoImportable: isAutoImportable };
+            function createInfo(modulePaths, moduleSpecifiers, isBlockedByPackageJsonDependencies) {
+                return { modulePaths: modulePaths, moduleSpecifiers: moduleSpecifiers, isBlockedByPackageJsonDependencies: isBlockedByPackageJsonDependencies };
             }
         }
         server.createModuleSpecifierCache = createModuleSpecifierCache;