typescript 5.5.0-dev.20240412 → 5.5.0-dev.20240414

package/lib/typescript.js

@@ -256,6 +256,7 @@ __export(typescript_exports, {
   canHaveJSDoc: () => canHaveJSDoc,
   canHaveLocals: () => canHaveLocals,
   canHaveModifiers: () => canHaveModifiers,
+  canHaveModuleSpecifier: () => canHaveModuleSpecifier,
   canHaveSymbol: () => canHaveSymbol,
   canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
   canProduceDiagnostics: () => canProduceDiagnostics,
@@ -722,6 +723,7 @@ __export(typescript_exports, {
   getDefaultLibFileName: () => getDefaultLibFileName,
   getDefaultLibFilePath: () => getDefaultLibFilePath,
   getDefaultLikeExportInfo: () => getDefaultLikeExportInfo,
+  getDefaultResolutionModeForFileWorker: () => getDefaultResolutionModeForFileWorker,
   getDiagnosticText: () => getDiagnosticText,
   getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan,
   getDirectoryPath: () => getDirectoryPath,
@@ -752,6 +754,7 @@ __export(typescript_exports, {
   getEmitFlags: () => getEmitFlags,
   getEmitHelpers: () => getEmitHelpers,
   getEmitModuleDetectionKind: () => getEmitModuleDetectionKind,
+  getEmitModuleFormatOfFileWorker: () => getEmitModuleFormatOfFileWorker,
   getEmitModuleKind: () => getEmitModuleKind,
   getEmitModuleResolutionKind: () => getEmitModuleResolutionKind,
   getEmitScriptTarget: () => getEmitScriptTarget,
@@ -802,6 +805,7 @@ __export(typescript_exports, {
   getIdentifierGeneratedImportReference: () => getIdentifierGeneratedImportReference,
   getIdentifierTypeArguments: () => getIdentifierTypeArguments,
   getImmediatelyInvokedFunctionExpression: () => getImmediatelyInvokedFunctionExpression,
+  getImpliedNodeFormatForEmitWorker: () => getImpliedNodeFormatForEmitWorker,
   getImpliedNodeFormatForFile: () => getImpliedNodeFormatForFile,
   getImpliedNodeFormatForFileWorker: () => getImpliedNodeFormatForFileWorker,
   getImportNeedsImportDefaultHelper: () => getImportNeedsImportDefaultHelper,
@@ -1157,6 +1161,7 @@ __export(typescript_exports, {
   importDefaultHelper: () => importDefaultHelper,
   importFromModuleSpecifier: () => importFromModuleSpecifier,
   importStarHelper: () => importStarHelper,
+  importSyntaxAffectsModuleResolution: () => importSyntaxAffectsModuleResolution,
   indexOfAnyCharCode: () => indexOfAnyCharCode,
   indexOfNode: () => indexOfNode,
   indicesOf: () => indicesOf,
@@ -2246,11 +2251,11 @@ __export(typescript_exports, {
   transformESDecorators: () => transformESDecorators,
   transformESNext: () => transformESNext,
   transformGenerators: () => transformGenerators,
+  transformImpliedNodeFormatDependentModule: () => transformImpliedNodeFormatDependentModule,
   transformJsx: () => transformJsx,
   transformLegacyDecorators: () => transformLegacyDecorators,
   transformModule: () => transformModule,
   transformNamedEvaluation: () => transformNamedEvaluation,
-  transformNodeModule: () => transformNodeModule,
   transformNodes: () => transformNodes,
   transformSystemModule: () => transformSystemModule,
   transformTypeScript: () => transformTypeScript,
@@ -2342,7 +2347,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240412`;
+var version = `${versionMajorMinor}.0-dev.20240414`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7855,7 +7860,7 @@ function createDirectoryWatcherSupportingRecursive({
   const filePathComparer = getStringComparer(!useCaseSensitiveFileNames2);
   const toCanonicalFilePath = createGetCanonicalFileName(useCaseSensitiveFileNames2);
   return (dirName, callback, recursive, options) => recursive ? createDirectoryWatcher(dirName, options, callback) : watchDirectory(dirName, callback, recursive, options);
-  function createDirectoryWatcher(dirName, options, callback) {
+  function createDirectoryWatcher(dirName, options, callback, link) {
     const dirPath = toCanonicalFilePath(dirName);
     let directoryWatcher = cache.get(dirPath);
     if (directoryWatcher) {
@@ -7865,10 +7870,12 @@ function createDirectoryWatcherSupportingRecursive({
         watcher: watchDirectory(
           dirName,
           (fileName) => {
+            var _a;
             if (isIgnoredPath(fileName, options))
               return;
             if (options == null ? void 0 : options.synchronousWatchDirectory) {
-              invokeCallbacks(dirPath, fileName);
+              if (!((_a = cache.get(dirPath)) == null ? void 0 : _a.targetWatcher))
+                invokeCallbacks(dirName, dirPath, fileName);
               updateChildWatches(dirName, dirPath, options);
             } else {
               nonSyncUpdateChildWatches(dirName, dirPath, fileName, options);
@@ -7879,11 +7886,15 @@ function createDirectoryWatcherSupportingRecursive({
           options
         ),
         refCount: 1,
-        childWatches: emptyArray
+        childWatches: emptyArray,
+        targetWatcher: void 0,
+        links: void 0
       };
       cache.set(dirPath, directoryWatcher);
       updateChildWatches(dirName, dirPath, options);
     }
+    if (link)
+      (directoryWatcher.links ?? (directoryWatcher.links = /* @__PURE__ */ new Set())).add(link);
     const callbackToAdd = callback && { dirName, callback };
     if (callbackToAdd) {
       callbackCache.add(dirPath, callbackToAdd);
@@ -7891,19 +7902,25 @@ function createDirectoryWatcherSupportingRecursive({
     return {
       dirName,
       close: () => {
+        var _a;
         const directoryWatcher2 = Debug.checkDefined(cache.get(dirPath));
         if (callbackToAdd)
           callbackCache.remove(dirPath, callbackToAdd);
+        if (link)
+          (_a = directoryWatcher2.links) == null ? void 0 : _a.delete(link);
         directoryWatcher2.refCount--;
         if (directoryWatcher2.refCount)
           return;
         cache.delete(dirPath);
+        directoryWatcher2.links = void 0;
         closeFileWatcherOf(directoryWatcher2);
+        closeTargetWatcher(directoryWatcher2);
         directoryWatcher2.childWatches.forEach(closeFileWatcher);
       }
     };
   }
-  function invokeCallbacks(dirPath, fileNameOrInvokeMap, fileNames) {
+  function invokeCallbacks(dirName, dirPath, fileNameOrInvokeMap, fileNames) {
+    var _a, _b;
     let fileName;
     let invokeMap;
     if (isString(fileNameOrInvokeMap)) {
@@ -7931,6 +7948,14 @@ function createDirectoryWatcherSupportingRecursive({
         }
       }
     });
+    (_b = (_a = cache.get(dirPath)) == null ? void 0 : _a.links) == null ? void 0 : _b.forEach((link) => {
+      const toPathInLink = (fileName2) => combinePaths(link, getRelativePathFromDirectory(dirName, fileName2, toCanonicalFilePath));
+      if (invokeMap) {
+        invokeCallbacks(link, toCanonicalFilePath(link), invokeMap, fileNames == null ? void 0 : fileNames.map(toPathInLink));
+      } else {
+        invokeCallbacks(link, toCanonicalFilePath(link), toPathInLink(fileName));
+      }
+    });
   }
   function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
     const parentWatcher = cache.get(dirPath);
@@ -7938,7 +7963,8 @@ function createDirectoryWatcherSupportingRecursive({
       scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
       return;
     }
-    invokeCallbacks(dirPath, fileName);
+    invokeCallbacks(dirName, dirPath, fileName);
+    closeTargetWatcher(parentWatcher);
     removeChildWatches(parentWatcher);
   }
   function scheduleUpdateChildWatches(dirName, dirPath, fileName, options) {
@@ -7955,6 +7981,7 @@ function createDirectoryWatcherSupportingRecursive({
     timerToUpdateChildWatches = setTimeout2(onTimerToUpdateChildWatches, 1e3, "timerToUpdateChildWatches");
   }
   function onTimerToUpdateChildWatches() {
+    var _a;
     timerToUpdateChildWatches = void 0;
     sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
     const start = timestamp();
@@ -7965,7 +7992,8 @@ function createDirectoryWatcherSupportingRecursive({
       const { value: [dirPath, { dirName, options, fileNames }] } = result;
       cacheToUpdateChildWatches.delete(dirPath);
       const hasChanges = updateChildWatches(dirName, dirPath, options);
-      invokeCallbacks(dirPath, invokeMap, hasChanges ? void 0 : fileNames);
+      if (!((_a = cache.get(dirPath)) == null ? void 0 : _a.targetWatcher))
+        invokeCallbacks(dirName, dirPath, invokeMap, hasChanges ? void 0 : fileNames);
     }
     sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp() - start}ms:: ${cacheToUpdateChildWatches.size}`);
     callbackCache.forEach((callbacks, rootDirName) => {
@@ -7993,22 +8021,46 @@ function createDirectoryWatcherSupportingRecursive({
       removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName)));
     }
   }
+  function closeTargetWatcher(watcher) {
+    if (watcher == null ? void 0 : watcher.targetWatcher) {
+      watcher.targetWatcher.close();
+      watcher.targetWatcher = void 0;
+    }
+  }
   function updateChildWatches(parentDir, parentDirPath, options) {
     const parentWatcher = cache.get(parentDirPath);
     if (!parentWatcher)
       return false;
+    const target = normalizePath(realpath(parentDir));
+    let hasChanges;
     let newChildWatches;
-    const hasChanges = enumerateInsertsAndDeletes(
-      fileSystemEntryExists(parentDir, 1 /* Directory */) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
-        const childFullName = getNormalizedAbsolutePath(child, parentDir);
-        return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : void 0;
-      }) : emptyArray,
-      parentWatcher.childWatches,
-      (child, childWatcher) => filePathComparer(child, childWatcher.dirName),
-      createAndAddChildDirectoryWatcher,
-      closeFileWatcher,
-      addChildDirectoryWatcher
-    );
+    if (filePathComparer(target, parentDir) === 0 /* EqualTo */) {
+      hasChanges = enumerateInsertsAndDeletes(
+        fileSystemEntryExists(parentDir, 1 /* Directory */) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
+          const childFullName = getNormalizedAbsolutePath(child, parentDir);
+          return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : void 0;
+        }) : emptyArray,
+        parentWatcher.childWatches,
+        (child, childWatcher) => filePathComparer(child, childWatcher.dirName),
+        createAndAddChildDirectoryWatcher,
+        closeFileWatcher,
+        addChildDirectoryWatcher
+      );
+    } else if (parentWatcher.targetWatcher && filePathComparer(target, parentWatcher.targetWatcher.dirName) === 0 /* EqualTo */) {
+      hasChanges = false;
+      Debug.assert(parentWatcher.childWatches === emptyArray);
+    } else {
+      closeTargetWatcher(parentWatcher);
+      parentWatcher.targetWatcher = createDirectoryWatcher(
+        target,
+        options,
+        /*callback*/
+        void 0,
+        parentDir
+      );
+      parentWatcher.childWatches.forEach(closeFileWatcher);
+      hasChanges = true;
+    }
     parentWatcher.childWatches = newChildWatches || emptyArray;
     return hasChanges;
     function createAndAddChildDirectoryWatcher(childName) {
@@ -9527,6 +9579,7 @@ var Diagnostics = {
   _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1290, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1290", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
   _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: diag(1291, 1 /* Error */, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1291", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."),
   _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1292, 1 /* Error */, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1292", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
+  ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve: diag(1293, 1 /* Error */, "ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve_1293", "ESM syntax is not allowed in a CommonJS module when 'module' is set to 'preserve'."),
   with_statements_are_not_allowed_in_an_async_function_block: diag(1300, 1 /* Error */, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
   await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, 1 /* Error */, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
   The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, 1 /* Error */, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
@@ -16095,7 +16148,7 @@ function canUseOriginalText(node, flags) {
   return !isBigIntLiteral(node);
 }
 function getTextOfConstantValue(value) {
-  return isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value;
+  return isString(value) ? `"${escapeString(value)}"` : "" + value;
 }
 function makeIdentifierFromModuleName(moduleName) {
   return getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");
@@ -17608,6 +17661,23 @@ function isFunctionSymbol(symbol) {
   const decl = symbol.valueDeclaration;
   return decl.kind === 262 /* FunctionDeclaration */ || isVariableDeclaration(decl) && decl.initializer && isFunctionLike(decl.initializer);
 }
+function canHaveModuleSpecifier(node) {
+  switch (node == null ? void 0 : node.kind) {
+    case 260 /* VariableDeclaration */:
+    case 208 /* BindingElement */:
+    case 272 /* ImportDeclaration */:
+    case 278 /* ExportDeclaration */:
+    case 271 /* ImportEqualsDeclaration */:
+    case 273 /* ImportClause */:
+    case 280 /* NamespaceExport */:
+    case 274 /* NamespaceImport */:
+    case 281 /* ExportSpecifier */:
+    case 276 /* ImportSpecifier */:
+    case 205 /* ImportType */:
+      return true;
+  }
+  return false;
+}
 function tryGetModuleSpecifierFromDeclaration(node) {
   var _a, _b;
   switch (node.kind) {
@@ -20585,8 +20655,8 @@ function walkTreeForJSXTags(node) {
 function isFileModuleFromUsingJSXTag(file) {
   return !file.isDeclarationFile ? walkTreeForJSXTags(file) : void 0;
 }
-function isFileForcedToBeModuleByFormat(file) {
-  return (file.impliedNodeFormat === 99 /* ESNext */ || fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */])) && !file.isDeclarationFile ? true : void 0;
+function isFileForcedToBeModuleByFormat(file, options) {
+  return (getImpliedNodeFormatForEmitWorker(file, options) === 99 /* ESNext */ || fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */])) && !file.isDeclarationFile ? true : void 0;
 }
 function getSetExternalModuleIndicator(options) {
   switch (getEmitModuleDetectionKind(options)) {
@@ -20605,10 +20675,14 @@ function getSetExternalModuleIndicator(options) {
       }
       checks.push(isFileForcedToBeModuleByFormat);
       const combined = or(...checks);
-      const callback = (file) => void (file.externalModuleIndicator = combined(file));
+      const callback = (file) => void (file.externalModuleIndicator = combined(file, options));
       return callback;
   }
 }
+function importSyntaxAffectsModuleResolution(options) {
+  const moduleResolution = getEmitModuleResolutionKind(options);
+  return 3 /* Node16 */ <= moduleResolution && moduleResolution <= 99 /* NodeNext */ || getResolvePackageJsonExports(options) || getResolvePackageJsonImports(options);
+}
 function createComputedCompilerOptions(options) {
   return options;
 }
@@ -29960,7 +30034,7 @@ function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFacto
   if (compilerOptions.importHelpers && isEffectiveExternalModule(sourceFile, compilerOptions)) {
     let namedBindings;
     const moduleKind = getEmitModuleKind(compilerOptions);
-    if (moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */ || sourceFile.impliedNodeFormat === 99 /* ESNext */) {
+    if (moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */ || getImpliedNodeFormatForEmitWorker(sourceFile, compilerOptions) === 99 /* ESNext */) {
       const helpers = getEmitHelpers(sourceFile);
       if (helpers) {
         const helperNames = [];
@@ -30025,8 +30099,7 @@ function getOrCreateExternalHelpersModuleNameIfNeeded(factory2, node, compilerOp
     if (externalHelpersModuleName) {
       return externalHelpersModuleName;
     }
-    const moduleKind = getEmitModuleKind(compilerOptions);
-    let create = (hasExportStarsToExportValues || getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || node.impliedNodeFormat === 1 /* CommonJS */);
+    let create = (hasExportStarsToExportValues || getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault) && getEmitModuleFormatOfFileWorker(node, compilerOptions) < 4 /* System */;
     if (!create) {
       const helpers = getEmitHelpers(node);
       if (helpers) {
@@ -47728,13 +47801,15 @@ var RelativePreference = /* @__PURE__ */ ((RelativePreference2) => {
   RelativePreference2[RelativePreference2["ExternalNonRelative"] = 3] = "ExternalNonRelative";
   return RelativePreference2;
 })(RelativePreference || {});
-function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }, compilerOptions, importingSourceFile, oldImportSpecifier) {
+function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }, host, compilerOptions, importingSourceFile, oldImportSpecifier) {
   const filePreferredEnding = getPreferredEnding();
   return {
     relativePreference: oldImportSpecifier !== void 0 ? isExternalModuleNameRelative(oldImportSpecifier) ? 0 /* Relative */ : 1 /* NonRelative */ : importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : 2 /* Shortest */,
     getAllowedEndingsInPreferredOrder: (syntaxImpliedNodeFormat) => {
-      const preferredEnding = syntaxImpliedNodeFormat !== importingSourceFile.impliedNodeFormat ? getPreferredEnding(syntaxImpliedNodeFormat) : filePreferredEnding;
-      if ((syntaxImpliedNodeFormat ?? importingSourceFile.impliedNodeFormat) === 99 /* ESNext */) {
+      const impliedNodeFormat = getDefaultResolutionModeForFile(importingSourceFile, host, compilerOptions);
+      const preferredEnding = syntaxImpliedNodeFormat !== impliedNodeFormat ? getPreferredEnding(syntaxImpliedNodeFormat) : filePreferredEnding;
+      const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
+      if ((syntaxImpliedNodeFormat ?? impliedNodeFormat) === 99 /* ESNext */ && 3 /* Node16 */ <= moduleResolution && moduleResolution <= 99 /* NodeNext */) {
         if (shouldAllowImportingTsExtension(compilerOptions, importingSourceFile.fileName)) {
           return [3 /* TsExtension */, 2 /* JsExtension */];
         }
@@ -47767,20 +47842,20 @@ function getModuleSpecifierPreferences({ importModuleSpecifierPreference, import
     }
     return getModuleSpecifierEndingPreference(
       importModuleSpecifierEnding,
-      resolutionMode ?? importingSourceFile.impliedNodeFormat,
+      resolutionMode ?? getDefaultResolutionModeForFile(importingSourceFile, host, compilerOptions),
       compilerOptions,
       isFullSourceFile(importingSourceFile) ? importingSourceFile : void 0
     );
   }
 }
 function updateModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, oldImportSpecifier, options = {}) {
-  const res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getModuleSpecifierPreferences({}, compilerOptions, importingSourceFile, oldImportSpecifier), {}, options);
+  const res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getModuleSpecifierPreferences({}, host, compilerOptions, importingSourceFile, oldImportSpecifier), {}, options);
   if (res === oldImportSpecifier)
     return void 0;
   return res;
 }
 function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, options = {}) {
-  return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getModuleSpecifierPreferences({}, compilerOptions, importingSourceFile), {}, options);
+  return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getModuleSpecifierPreferences({}, host, compilerOptions, importingSourceFile), {}, options);
 }
 function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences, options = {}) {
   const info = getInfo(importingSourceFile.fileName, host);
@@ -47810,7 +47885,7 @@ function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importin
     /*packageNameOnly*/
     void 0,
     options.overrideImportMode
-  )) || getLocalModuleSpecifier(toFileName2, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
+  )) || getLocalModuleSpecifier(toFileName2, info, compilerOptions, host, options.overrideImportMode || getDefaultResolutionModeForFile(importingSourceFile, host, compilerOptions), preferences);
 }
 function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences, options = {}) {
   return tryGetModuleSpecifiersFromCacheWorker(
@@ -47883,19 +47958,22 @@ function getLocalModuleSpecifierBetweenFileNames(importingFile, targetFileName,
     compilerOptions,
     host,
     importMode,
-    getModuleSpecifierPreferences({}, compilerOptions, importingFile)
+    getModuleSpecifierPreferences({}, host, compilerOptions, importingFile)
   );
 }
 function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
   const info = getInfo(importingSourceFile.fileName, host);
-  const preferences = getModuleSpecifierPreferences(userPreferences, compilerOptions, importingSourceFile);
+  const preferences = getModuleSpecifierPreferences(userPreferences, host, compilerOptions, importingSourceFile);
   const existingSpecifier = isFullSourceFile(importingSourceFile) && forEach(modulePaths, (modulePath) => forEach(
     host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
     (reason) => {
       if (reason.kind !== 3 /* Import */ || reason.file !== importingSourceFile.path)
         return void 0;
-      if (importingSourceFile.impliedNodeFormat && importingSourceFile.impliedNodeFormat !== getModeForResolutionAtIndex(importingSourceFile, reason.index, compilerOptions))
+      const existingMode = host.getModeForResolutionAtIndex(importingSourceFile, reason.index);
+      const targetMode = options.overrideImportMode ?? host.getDefaultResolutionModeForFile(importingSourceFile);
+      if (existingMode !== targetMode && existingMode !== void 0 && targetMode !== void 0) {
         return void 0;
+      }
       const specifier = getModuleNameStringLiteralAt(importingSourceFile, reason.index).text;
       return preferences.relativePreference !== 1 /* NonRelative */ || !pathIsRelative(specifier) ? specifier : void 0;
     }
@@ -48406,7 +48484,7 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
   if (!parts) {
     return void 0;
   }
-  const preferences = getModuleSpecifierPreferences(userPreferences, options, importingSourceFile);
+  const preferences = getModuleSpecifierPreferences(userPreferences, host, options, importingSourceFile);
   const allowedEndings = preferences.getAllowedEndingsInPreferredOrder();
   let moduleSpecifier = path;
   let isPackageRootPath = false;
@@ -48457,7 +48535,7 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
     const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
     if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
       const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || tryParseJson(host.readFile(packageJsonPath));
-      const importMode = overrideMode || importingSourceFile.impliedNodeFormat;
+      const importMode = overrideMode || getDefaultResolutionModeForFile(importingSourceFile, host, options);
       if (getResolvePackageJsonExports(options)) {
         const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
         const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2);
@@ -48609,6 +48687,9 @@ function getRelativePathIfInSameVolume(path, directoryPath, getCanonicalFileName
 function isPathRelativeToParent(path) {
   return startsWith(path, "..");
 }
+function getDefaultResolutionModeForFile(file, host, compilerOptions) {
+  return isFullSourceFile(file) ? host.getDefaultResolutionModeForFile(file) : getDefaultResolutionModeForFileWorker(file, compilerOptions);
+}
 
 // src/compiler/checker.ts
 var ambientModuleSymbolRegex = /^".+"$/;
@@ -50830,22 +50911,28 @@ function createTypeChecker(host) {
   function isSyntacticDefault(node) {
     return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 2048 /* Default */) || isExportSpecifier(node) || isNamespaceExport(node);
   }
-  function getUsageModeForExpression(usage) {
-    return isStringLiteralLike(usage) ? host.getModeForUsageLocation(getSourceFileOfNode(usage), usage) : void 0;
+  function getEmitSyntaxForModuleSpecifierExpression(usage) {
+    return isStringLiteralLike(usage) ? host.getEmitSyntaxForUsageLocation(getSourceFileOfNode(usage), usage) : void 0;
   }
   function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
     return usageMode === 99 /* ESNext */ && targetMode === 1 /* CommonJS */;
   }
-  function isOnlyImportedAsDefault(usage) {
-    const usageMode = getUsageModeForExpression(usage);
-    return usageMode === 99 /* ESNext */ && endsWith(usage.text, ".json" /* Json */);
+  function isOnlyImportableAsDefault(usage) {
+    if (100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */) {
+      const usageMode = getEmitSyntaxForModuleSpecifierExpression(usage);
+      return usageMode === 99 /* ESNext */ && endsWith(usage.text, ".json" /* Json */);
+    }
+    return false;
   }
   function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
-    const usageMode = file && getUsageModeForExpression(usage);
-    if (file && usageMode !== void 0 && 100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */) {
-      const result = isESMFormatImportImportingCommonjsFormatFile(usageMode, file.impliedNodeFormat);
-      if (usageMode === 99 /* ESNext */ || result) {
-        return result;
+    const usageMode = file && getEmitSyntaxForModuleSpecifierExpression(usage);
+    if (file && usageMode !== void 0) {
+      const targetMode = host.getImpliedNodeFormatForEmit(file);
+      if (usageMode === 99 /* ESNext */ && targetMode === 1 /* CommonJS */ && 100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */) {
+        return true;
+      }
+      if (usageMode === 99 /* ESNext */ && targetMode === 99 /* ESNext */) {
+        return false;
       }
     }
     if (!allowSyntheticDefaultImports) {
@@ -50904,7 +50991,7 @@ function createTypeChecker(host) {
     if (!specifier) {
       return exportDefaultSymbol;
     }
-    const hasDefaultOnly = isOnlyImportedAsDefault(specifier);
+    const hasDefaultOnly = isOnlyImportableAsDefault(specifier);
     const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier);
     if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) {
       if (hasExportAssignmentSymbol(moduleSymbol) && !allowSyntheticDefaultImports) {
@@ -51108,7 +51195,7 @@ function createTypeChecker(host) {
         let symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
         if (symbolFromModule === void 0 && name.escapedText === "default" /* Default */) {
           const file = (_a = moduleSymbol.declarations) == null ? void 0 : _a.find(isSourceFile);
-          if (isOnlyImportedAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
+          if (isOnlyImportableAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
             symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
           }
         }
@@ -51738,7 +51825,7 @@ function createTypeChecker(host) {
       /*requireStringLiteralLikeArgument*/
       true
     ) ? location.initializer.arguments[0] : void 0) || ((_c = findAncestor(location, isImportCall)) == null ? void 0 : _c.arguments[0]) || ((_d = findAncestor(location, isImportDeclaration)) == null ? void 0 : _d.moduleSpecifier) || ((_e = findAncestor(location, isExternalModuleImportEqualsDeclaration)) == null ? void 0 : _e.moduleReference.expression) || ((_f = findAncestor(location, isExportDeclaration)) == null ? void 0 : _f.moduleSpecifier);
-    const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? host.getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
+    const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? host.getModeForUsageLocation(currentSourceFile, contextSpecifier) : host.getDefaultResolutionModeForFile(currentSourceFile);
     const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
     const resolvedModule = (_g = host.getResolvedModule(currentSourceFile, moduleReference, mode)) == null ? void 0 : _g.resolvedModule;
     const resolutionDiagnostic = resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule, currentSourceFile);
@@ -51983,7 +52070,7 @@ function createTypeChecker(host) {
           return cloneTypeAsModuleType(symbol, defaultOnlyType, referenceParent);
         }
         const targetFile = (_a = moduleSymbol == null ? void 0 : moduleSymbol.declarations) == null ? void 0 : _a.find(isSourceFile);
-        const isEsmCjsRef = targetFile && isESMFormatImportImportingCommonjsFormatFile(getUsageModeForExpression(reference), targetFile.impliedNodeFormat);
+        const isEsmCjsRef = targetFile && isESMFormatImportImportingCommonjsFormatFile(getEmitSyntaxForModuleSpecifierExpression(reference), host.getImpliedNodeFormatForEmit(targetFile));
         if (getESModuleInterop(compilerOptions) || isEsmCjsRef) {
           let sigs = getSignaturesOfStructuredType(type, 0 /* Call */);
           if (!sigs || !sigs.length) {
@@ -54536,14 +54623,16 @@ function createTypeChecker(host) {
           return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
         }
       }
-      if (!context.enclosingDeclaration || !context.tracker.moduleResolverHost) {
+      if (!context.enclosingFile || !context.tracker.moduleResolverHost) {
         if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
           return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
         }
         return getSourceFileOfNode(getNonAugmentationDeclaration(symbol)).fileName;
       }
-      const contextFile = getSourceFileOfNode(getOriginalNode(context.enclosingDeclaration));
-      const resolutionMode = overrideImportMode || (contextFile == null ? void 0 : contextFile.impliedNodeFormat);
+      const enclosingDeclaration = getOriginalNode(context.enclosingDeclaration);
+      const originalModuleSpecifier = canHaveModuleSpecifier(enclosingDeclaration) ? tryGetModuleSpecifierFromDeclaration(enclosingDeclaration) : void 0;
+      const contextFile = context.enclosingFile;
+      const resolutionMode = overrideImportMode || originalModuleSpecifier && host.getModeForUsageLocation(contextFile, originalModuleSpecifier) || contextFile && host.getDefaultResolutionModeForFile(contextFile);
       const cacheKey = createModeAwareCacheKey(contextFile.path, resolutionMode);
       const links = getSymbolLinks(symbol);
       let specifier = links.specifierCache && links.specifierCache.get(cacheKey);
@@ -55279,22 +55368,16 @@ function createTypeChecker(host) {
           return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
         }
         function rewriteModuleSpecifier(parent2, lit) {
-          if (context.bundled) {
-            if (context.tracker && context.tracker.moduleResolverHost) {
-              const targetFile = getExternalModuleFileFromDeclaration(parent2);
-              if (targetFile) {
-                const getCanonicalFileName = createGetCanonicalFileName(!!host.useCaseSensitiveFileNames);
-                const resolverHost = {
-                  getCanonicalFileName,
-                  getCurrentDirectory: () => context.tracker.moduleResolverHost.getCurrentDirectory(),
-                  getCommonSourceDirectory: () => context.tracker.moduleResolverHost.getCommonSourceDirectory()
-                };
-                const newName = getResolvedExternalModuleName(resolverHost, targetFile);
-                return factory.createStringLiteral(newName);
+          if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
+            const targetFile = getExternalModuleFileFromDeclaration(parent2);
+            if (targetFile) {
+              const newName = getSpecifierForModuleSymbol(targetFile.symbol, context);
+              if (newName !== lit.text) {
+                return setOriginalNode(factory.createStringLiteral(newName), lit);
               }
             }
           }
-          return lit;
+          return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
         }
       }
     }
@@ -77385,6 +77468,7 @@ function createTypeChecker(host) {
       candidateForTypeArgumentError = oldCandidateForTypeArgumentError;
     }
     function chooseOverload(candidates2, relation, isSingleNonGenericCandidate2, signatureHelpTrailingComma2 = false) {
+      var _a, _b;
       candidatesForArgumentError = void 0;
       candidateForArgumentArityError = void 0;
       candidateForTypeArgumentError = void 0;
@@ -77419,7 +77503,9 @@ function createTypeChecker(host) {
         let checkCandidate;
         let inferenceContext;
         if (candidate.typeParameters) {
-          if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
+          const paramLocation = (_b = (_a = candidate.typeParameters[0].symbol.declarations) == null ? void 0 : _a[0]) == null ? void 0 : _b.parent;
+          const candidateParameterContext = paramLocation || (candidate.declaration && isConstructorDeclaration(candidate.declaration) ? candidate.declaration.parent : candidate.declaration);
+          if (candidateParameterContext && findAncestor(node, (a) => a === candidateParameterContext)) {
             candidate = getImplementationSignature(candidate);
           }
           let typeArgumentTypes;
@@ -78365,7 +78451,7 @@ function createTypeChecker(host) {
     return createAnonymousType(anonymousSymbol, memberTable, emptyArray, emptyArray, emptyArray);
   }
   function getTypeWithSyntheticDefaultOnly(type, symbol, originalSymbol, moduleSpecifier) {
-    const hasDefaultOnly = isOnlyImportedAsDefault(moduleSpecifier);
+    const hasDefaultOnly = isOnlyImportableAsDefault(moduleSpecifier);
     if (hasDefaultOnly && type && !isErrorType(type)) {
       const synthType = type;
       if (!synthType.defaultOnlyType) {
@@ -83702,7 +83788,7 @@ function createTypeChecker(host) {
     });
   }
   function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
-    if (moduleKind >= 5 /* ES2015 */ && !(moduleKind >= 100 /* Node16 */ && getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
+    if (host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) >= 5 /* ES2015 */) {
       return;
     }
     if (!name || !needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
@@ -85131,7 +85217,7 @@ function createTypeChecker(host) {
     }
   }
   function checkClassNameCollisionWithObject(name) {
-    if (languageVersion >= 1 /* ES5 */ && name.escapedText === "Object" && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(name).impliedNodeFormat === 1 /* CommonJS */)) {
+    if (languageVersion >= 1 /* ES5 */ && name.escapedText === "Object" && host.getEmitModuleFormatOfFile(getSourceFileOfNode(name)) < 5 /* ES2015 */) {
       error2(name, Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ModuleKind[moduleKind]);
     }
   }
@@ -86201,7 +86287,7 @@ function createTypeChecker(host) {
             getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
           }
         }
-        if (compilerOptions.verbatimModuleSyntax && node.parent.kind === 307 /* SourceFile */ && (moduleKind === 1 /* CommonJS */ || node.parent.impliedNodeFormat === 1 /* CommonJS */)) {
+        if (compilerOptions.verbatimModuleSyntax && node.parent.kind === 307 /* SourceFile */ && host.getEmitModuleFormatOfFile(node.parent) === 1 /* CommonJS */) {
           const exportModifier = (_b = node.modifiers) == null ? void 0 : _b.find((m) => m.kind === 95 /* ExportKeyword */);
           if (exportModifier) {
             error2(exportModifier, Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
@@ -86411,8 +86497,10 @@ function createTypeChecker(host) {
             }
           }
         }
-        if (compilerOptions.verbatimModuleSyntax && node.kind !== 271 /* ImportEqualsDeclaration */ && !isInJSFile(node) && (moduleKind === 1 /* CommonJS */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
+        if (compilerOptions.verbatimModuleSyntax && node.kind !== 271 /* ImportEqualsDeclaration */ && !isInJSFile(node) && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === 1 /* CommonJS */) {
           error2(node, Diagnostics.ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
+        } else if (moduleKind === 200 /* Preserve */ && node.kind !== 271 /* ImportEqualsDeclaration */ && node.kind !== 260 /* VariableDeclaration */ && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === 1 /* CommonJS */) {
+          error2(node, Diagnostics.ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve);
         }
       }
       if (isImportSpecifier(node)) {
@@ -86454,7 +86542,7 @@ function createTypeChecker(host) {
   function checkImportBinding(node) {
     checkCollisionsForDeclarationName(node, node.name);
     checkAliasSymbol(node);
-    if (node.kind === 276 /* ImportSpecifier */ && idText(node.propertyName || node.name) === "default" && getESModuleInterop(compilerOptions) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
+    if (node.kind === 276 /* ImportSpecifier */ && idText(node.propertyName || node.name) === "default" && getESModuleInterop(compilerOptions) && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */) {
       checkExternalEmitHelpers(node, 131072 /* ImportDefault */);
     }
   }
@@ -86475,7 +86563,7 @@ function createTypeChecker(host) {
       if (validForTypeAttributes && override) {
         return;
       }
-      const mode = moduleKind === 199 /* NodeNext */ && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
+      const mode = moduleKind === 199 /* NodeNext */ && declaration.moduleSpecifier && getEmitSyntaxForModuleSpecifierExpression(declaration.moduleSpecifier);
       if (mode !== 99 /* ESNext */ && moduleKind !== 99 /* ESNext */ && moduleKind !== 200 /* Preserve */) {
         const message = isImportAttributes2 ? moduleKind === 199 /* NodeNext */ ? Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve : moduleKind === 199 /* NodeNext */ ? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve;
         return grammarErrorOnNode(node, message);
@@ -86508,7 +86596,7 @@ function createTypeChecker(host) {
         if (importClause.namedBindings) {
           if (importClause.namedBindings.kind === 274 /* NamespaceImport */) {
             checkImportBinding(importClause.namedBindings);
-            if (moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && getESModuleInterop(compilerOptions)) {
+            if (host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */ && getESModuleInterop(compilerOptions)) {
               checkExternalEmitHelpers(node, 65536 /* ImportStar */);
             }
           } else {
@@ -86550,7 +86638,7 @@ function createTypeChecker(host) {
           grammarErrorOnNode(node, Diagnostics.An_import_alias_cannot_use_import_type);
         }
       } else {
-        if (moduleKind >= 5 /* ES2015 */ && moduleKind !== 200 /* Preserve */ && getSourceFileOfNode(node).impliedNodeFormat === void 0 && !node.isTypeOnly && !(node.flags & 33554432 /* Ambient */)) {
+        if (5 /* ES2015 */ <= moduleKind && moduleKind <= 99 /* ESNext */ && !node.isTypeOnly && !(node.flags & 33554432 /* Ambient */)) {
           grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
         }
       }
@@ -86579,7 +86667,7 @@ function createTypeChecker(host) {
         } else if (node.exportClause) {
           checkAliasSymbol(node.exportClause);
         }
-        if (moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
+        if (host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */) {
           if (node.exportClause) {
             if (getESModuleInterop(compilerOptions)) {
               checkExternalEmitHelpers(node, 65536 /* ImportStar */);
@@ -86638,7 +86726,7 @@ function createTypeChecker(host) {
         }
       }
     } else {
-      if (getESModuleInterop(compilerOptions) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && idText(node.propertyName || node.name) === "default") {
+      if (getESModuleInterop(compilerOptions) && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */ && idText(node.propertyName || node.name) === "default") {
         checkExternalEmitHelpers(node, 131072 /* ImportDefault */);
       }
     }
@@ -86664,7 +86752,7 @@ function createTypeChecker(host) {
     if (typeAnnotationNode) {
       checkTypeAssignableTo(checkExpressionCached(node.expression), getTypeFromTypeNode(typeAnnotationNode), node.expression);
     }
-    const isIllegalExportDefaultInCJS = !node.isExportEquals && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && (moduleKind === 1 /* CommonJS */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */);
+    const isIllegalExportDefaultInCJS = !node.isExportEquals && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === 1 /* CommonJS */;
     if (node.expression.kind === 80 /* Identifier */) {
       const id = node.expression;
       const sym = getExportSymbolOfValueSymbolIfExported(resolveEntityName(
@@ -86744,7 +86832,7 @@ function createTypeChecker(host) {
       grammarErrorOnNode(node.expression, Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
     }
     if (node.isExportEquals) {
-      if (moduleKind >= 5 /* ES2015 */ && moduleKind !== 200 /* Preserve */ && (node.flags & 33554432 /* Ambient */ && getSourceFileOfNode(node).impliedNodeFormat === 99 /* ESNext */ || !(node.flags & 33554432 /* Ambient */) && getSourceFileOfNode(node).impliedNodeFormat !== 1 /* CommonJS */)) {
+      if (moduleKind >= 5 /* ES2015 */ && moduleKind !== 200 /* Preserve */ && (node.flags & 33554432 /* Ambient */ && host.getImpliedNodeFormatForEmit(getSourceFileOfNode(node)) === 99 /* ESNext */ || !(node.flags & 33554432 /* Ambient */) && host.getImpliedNodeFormatForEmit(getSourceFileOfNode(node)) !== 1 /* CommonJS */)) {
         grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
       } else if (moduleKind === 4 /* System */ && !(node.flags & 33554432 /* Ambient */)) {
         grammarErrorOnNode(node, Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
@@ -89125,7 +89213,7 @@ function createTypeChecker(host) {
             break;
           case 95 /* ExportKeyword */:
             if (compilerOptions.verbatimModuleSyntax && !(node.flags & 33554432 /* Ambient */) && node.kind !== 265 /* TypeAliasDeclaration */ && node.kind !== 264 /* InterfaceDeclaration */ && // ModuleDeclaration needs to be checked that it is uninstantiated later
-            node.kind !== 267 /* ModuleDeclaration */ && node.parent.kind === 307 /* SourceFile */ && (moduleKind === 1 /* CommonJS */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
+            node.kind !== 267 /* ModuleDeclaration */ && node.parent.kind === 307 /* SourceFile */ && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === 1 /* CommonJS */) {
               return grammarErrorOnNode(modifier, Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
             }
             if (flags & 32 /* Export */) {
@@ -90036,7 +90124,7 @@ function createTypeChecker(host) {
       const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
       return grammarErrorOnNode(node.exclamationToken, message);
     }
-    if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 33554432 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 32 /* Export */)) {
+    if (host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */ && !(node.parent.parent.flags & 33554432 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 32 /* Export */)) {
       checkESModuleMarker(node.name);
     }
     return !!blockScopeKind && checkGrammarNameInLetOrConstDeclarations(node.name);
@@ -90523,7 +90611,9 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host) {
     isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
     fileExists: (fileName) => host.fileExists(fileName),
     getFileIncludeReasons: () => host.getFileIncludeReasons(),
-    readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
+    readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0,
+    getDefaultResolutionModeForFile: (file) => host.getDefaultResolutionModeForFile(file),
+    getModeForResolutionAtIndex: (file, index) => host.getModeForResolutionAtIndex(file, index)
   };
 }
 var SymbolTrackerImpl = class _SymbolTrackerImpl {
@@ -109956,6 +110046,9 @@ function transformModule(context) {
     return updated;
   }
   function shouldEmitUnderscoreUnderscoreESModule() {
+    if (hasJSFileExtension(currentSourceFile.fileName) && currentSourceFile.commonJsModuleIndicator && (!currentSourceFile.externalModuleIndicator || currentSourceFile.externalModuleIndicator === true)) {
+      return false;
+    }
     if (!currentModuleInfo.exportEquals && isExternalModule(currentSourceFile)) {
       return true;
     }
@@ -110434,7 +110527,7 @@ function transformModule(context) {
       case 354 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 213 /* CallExpression */:
-        if (isImportCall(node) && currentSourceFile.impliedNodeFormat === void 0) {
+        if (isImportCall(node) && host.shouldTransformImportCall(currentSourceFile)) {
           return visitImportCallExpression(node);
         }
         break;
@@ -113435,8 +113528,8 @@ function transformECMAScriptModule(context) {
   }
 }
 
-// src/compiler/transformers/module/node.ts
-function transformNodeModule(context) {
+// src/compiler/transformers/module/impliedNodeFormatDependent.ts
+function transformImpliedNodeFormatDependentModule(context) {
   const previousOnSubstituteNode = context.onSubstituteNode;
   const previousOnEmitNode = context.onEmitNode;
   const esmTransform = transformECMAScriptModule(context);
@@ -113447,6 +113540,7 @@ function transformNodeModule(context) {
   const cjsTransform = transformModule(context);
   const cjsOnSubstituteNode = context.onSubstituteNode;
   const cjsOnEmitNode = context.onEmitNode;
+  const getEmitModuleFormatOfFile2 = (file) => context.getEmitHost().getEmitModuleFormatOfFile(file);
   context.onSubstituteNode = onSubstituteNode;
   context.onEmitNode = onEmitNode;
   context.enableSubstitution(307 /* SourceFile */);
@@ -113461,7 +113555,7 @@ function transformNodeModule(context) {
       if (!currentSourceFile) {
         return previousOnSubstituteNode(hint, node);
       }
-      if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
+      if (getEmitModuleFormatOfFile2(currentSourceFile) >= 5 /* ES2015 */) {
         return esmOnSubstituteNode(hint, node);
       }
       return cjsOnSubstituteNode(hint, node);
@@ -113474,13 +113568,13 @@ function transformNodeModule(context) {
     if (!currentSourceFile) {
       return previousOnEmitNode(hint, node, emitCallback);
     }
-    if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
+    if (getEmitModuleFormatOfFile2(currentSourceFile) >= 5 /* ES2015 */) {
       return esmOnEmitNode(hint, node, emitCallback);
     }
     return cjsOnEmitNode(hint, node, emitCallback);
   }
   function getModuleTransformForFile(file) {
-    return file.impliedNodeFormat === 99 /* ESNext */ ? esmTransform : cjsTransform;
+    return getEmitModuleFormatOfFile2(file) >= 5 /* ES2015 */ ? esmTransform : cjsTransform;
   }
   function transformSourceFile(node) {
     if (node.isDeclarationFile) {
@@ -115383,17 +115477,18 @@ function isProcessedComponent(node) {
 // src/compiler/transformer.ts
 function getModuleTransformer(moduleKind) {
   switch (moduleKind) {
+    case 200 /* Preserve */:
+      return transformECMAScriptModule;
     case 99 /* ESNext */:
     case 7 /* ES2022 */:
     case 6 /* ES2020 */:
     case 5 /* ES2015 */:
-    case 200 /* Preserve */:
-      return transformECMAScriptModule;
-    case 4 /* System */:
-      return transformSystemModule;
     case 100 /* Node16 */:
     case 199 /* NodeNext */:
-      return transformNodeModule;
+    case 1 /* CommonJS */:
+      return transformImpliedNodeFormatDependentModule;
+    case 4 /* System */:
+      return transformSystemModule;
     default:
       return transformModule;
   }
@@ -116128,6 +116223,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
       newLine: compilerOptions.newLine,
       noEmitHelpers: compilerOptions.noEmitHelpers,
       module: getEmitModuleKind(compilerOptions),
+      moduleResolution: getEmitModuleResolutionKind(compilerOptions),
       target: getEmitScriptTarget(compilerOptions),
       sourceMap: compilerOptions.sourceMap,
       inlineSourceMap: compilerOptions.inlineSourceMap,
@@ -116190,6 +116286,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
         newLine: compilerOptions.newLine,
         noEmitHelpers: true,
         module: compilerOptions.module,
+        moduleResolution: compilerOptions.moduleResolution,
         target: compilerOptions.target,
         sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
         inlineSourceMap: compilerOptions.inlineSourceMap,
@@ -121755,7 +121852,6 @@ function getModeForUsageLocation(file, usage, compilerOptions) {
   return getModeForUsageLocationWorker(file, usage, compilerOptions);
 }
 function getModeForUsageLocationWorker(file, usage, compilerOptions) {
-  var _a;
   if (isImportDeclaration(usage.parent) || isExportDeclaration(usage.parent)) {
     const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage.parent);
     if (isTypeOnly) {
@@ -121771,20 +121867,28 @@ function getModeForUsageLocationWorker(file, usage, compilerOptions) {
       return override;
     }
   }
-  if (compilerOptions && getEmitModuleKind(compilerOptions) === 200 /* Preserve */) {
-    return usage.parent.parent && isImportEqualsDeclaration(usage.parent.parent) || isRequireCall(
-      usage.parent,
-      /*requireStringLiteralLikeArgument*/
-      false
-    ) ? 1 /* CommonJS */ : 99 /* ESNext */;
+  if (compilerOptions && importSyntaxAffectsModuleResolution(compilerOptions)) {
+    return getEmitSyntaxForUsageLocationWorker(file, usage, compilerOptions);
   }
-  if (file.impliedNodeFormat === void 0)
+}
+function getEmitSyntaxForUsageLocationWorker(file, usage, compilerOptions) {
+  var _a;
+  if (!compilerOptions) {
     return void 0;
-  if (file.impliedNodeFormat !== 99 /* ESNext */) {
-    return isImportCall(walkUpParenthesizedExpressions(usage.parent)) ? 99 /* ESNext */ : 1 /* CommonJS */;
   }
   const exprParentParent = (_a = walkUpParenthesizedExpressions(usage.parent)) == null ? void 0 : _a.parent;
-  return exprParentParent && isImportEqualsDeclaration(exprParentParent) ? 1 /* CommonJS */ : 99 /* ESNext */;
+  if (exprParentParent && isImportEqualsDeclaration(exprParentParent) || isRequireCall(
+    usage.parent,
+    /*requireStringLiteralLikeArgument*/
+    false
+  )) {
+    return 1 /* CommonJS */;
+  }
+  if (isImportCall(walkUpParenthesizedExpressions(usage.parent))) {
+    return shouldTransformImportCallWorker(file, compilerOptions) ? 1 /* CommonJS */ : 99 /* ESNext */;
+  }
+  const fileEmitMode = getEmitModuleFormatOfFileWorker(file, compilerOptions);
+  return fileEmitMode === 1 /* CommonJS */ ? 1 /* CommonJS */ : emitModuleKindIsNonNodeESM(fileEmitMode) || fileEmitMode === 200 /* Preserve */ ? 99 /* ESNext */ : void 0;
 }
 function getResolutionModeOverride(node, grammarErrorOnNode) {
   if (!node)
@@ -121844,7 +121948,7 @@ function getTypeReferenceResolutionName(entry) {
 }
 var typeReferenceResolutionNameAndModeGetter = {
   getName: getTypeReferenceResolutionName,
-  getMode: (entry, file) => getModeForFileReference(entry, file == null ? void 0 : file.impliedNodeFormat)
+  getMode: (entry, file, compilerOptions) => getModeForFileReference(entry, file && getDefaultResolutionModeForFileWorker(file, compilerOptions))
 };
 function createTypeReferenceResolutionLoader(containingFile, redirectedReference, options, host, cache) {
   return {
@@ -122032,13 +122136,7 @@ function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, optio
   return typeof result === "object" ? result.impliedNodeFormat : result;
 }
 function getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options) {
-  switch (getEmitModuleResolutionKind(options)) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-      return fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".mjs" /* Mjs */]) ? 99 /* ESNext */ : fileExtensionIsOneOf(fileName, [".d.cts" /* Dcts */, ".cts" /* Cts */, ".cjs" /* Cjs */]) ? 1 /* CommonJS */ : fileExtensionIsOneOf(fileName, [".d.ts" /* Dts */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */]) ? lookupFromPackageJson() : void 0;
-    default:
-      return void 0;
-  }
+  return fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".mjs" /* Mjs */]) ? 99 /* ESNext */ : fileExtensionIsOneOf(fileName, [".d.cts" /* Dcts */, ".cts" /* Cts */, ".cjs" /* Cjs */]) ? 1 /* CommonJS */ : fileExtensionIsOneOf(fileName, [".d.ts" /* Dts */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */]) ? lookupFromPackageJson() : void 0;
   function lookupFromPackageJson() {
     const state = getTemporaryModuleResolutionState(packageJsonInfoCache, host, options);
     const packageJsonLocations = [];
@@ -122488,6 +122586,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     isSourceFileFromExternalLibrary,
     isSourceFileDefaultLibrary,
     getModeForUsageLocation: getModeForUsageLocation2,
+    getEmitSyntaxForUsageLocation,
     getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
     getSourceFileFromReference,
     getLibFileFromReference,
@@ -122515,6 +122614,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     forEachResolvedProjectReference: forEachResolvedProjectReference2,
     isSourceOfProjectReferenceRedirect,
     getRedirectReferenceForResolutionFromSourceOfProject,
+    getCompilerOptionsForFile,
+    getDefaultResolutionModeForFile: getDefaultResolutionModeForFile2,
+    getEmitModuleFormatOfFile: getEmitModuleFormatOfFile2,
+    getImpliedNodeFormatForEmit: getImpliedNodeFormatForEmit2,
+    shouldTransformImportCall,
     emitBuildInfo,
     fileExists,
     readFile,
@@ -123078,6 +123182,10 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       getSymlinkCache,
       writeFile: writeFileCallback || writeFile2,
       isEmitBlocked,
+      shouldTransformImportCall,
+      getEmitModuleFormatOfFile: getEmitModuleFormatOfFile2,
+      getDefaultResolutionModeForFile: getDefaultResolutionModeForFile2,
+      getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
       readFile: (f) => host.readFile(f),
       fileExists: (f) => {
         const path = toPath3(f);
@@ -124113,10 +124221,14 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       const resolvedTypeReferenceDirective = resolutions[index];
       const fileName = toFileNameLowerCase(ref.fileName);
       resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), resolvedTypeReferenceDirective);
-      const mode = ref.resolutionMode || file.impliedNodeFormat;
+      const mode = ref.resolutionMode || getDefaultResolutionModeForFile2(file);
       processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });
     }
   }
+  function getCompilerOptionsForFile(file) {
+    var _a2;
+    return ((_a2 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a2.commandLine.options) || options;
+  }
   function processTypeReferenceDirective(typeReferenceDirective, mode, resolution, reason) {
     var _a2, _b2;
     (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolution.resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
@@ -124264,13 +124376,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     return host.getCanonicalFileName(fileName);
   }
   function processImportedModules(file) {
-    var _a2;
     collectExternalModuleReferences(file);
     if (file.imports.length || file.moduleAugmentations.length) {
       const moduleNames = getModuleNames(file);
       const resolutions = (resolvedModulesProcessing == null ? void 0 : resolvedModulesProcessing.get(file.path)) || resolveModuleNamesReusingOldState(moduleNames, file);
       Debug.assert(resolutions.length === moduleNames.length);
-      const optionsForFile = ((_a2 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a2.commandLine.options) || options;
+      const optionsForFile = getCompilerOptionsForFile(file);
       const resolutionsInFile = createModeAwareCache();
       (resolvedModules ?? (resolvedModules = /* @__PURE__ */ new Map())).set(file.path, resolutionsInFile);
       for (let index = 0; index < moduleNames.length; index++) {
@@ -124806,7 +124917,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       fileIncludeReasons = void 0;
     const location = locationReason && getReferencedFileLocation(program, locationReason);
     const fileIncludeReasonDetails = fileIncludeReasons && chainDiagnosticMessages(fileIncludeReasons, Diagnostics.The_file_is_in_the_program_because_Colon);
-    const redirectInfo = file && explainIfFileIsRedirectAndImpliedFormat(file);
+    const optionsForFile = file && getCompilerOptionsForFile(file) || options;
+    const redirectInfo = file && explainIfFileIsRedirectAndImpliedFormat(file, optionsForFile);
     const chain = chainDiagnosticMessages(redirectInfo ? fileIncludeReasonDetails ? [fileIncludeReasonDetails, ...redirectInfo] : redirectInfo : fileIncludeReasonDetails, diagnostic, ...args || emptyArray);
     return location && isReferenceFileLocation(location) ? createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) : createCompilerDiagnosticFromMessageChain(chain, relatedInfo);
     function processReason(reason) {
@@ -125107,13 +125219,53 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     return symlinks;
   }
   function getModeForUsageLocation2(file, usage) {
-    var _a2;
-    const optionsForFile = ((_a2 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a2.commandLine.options) || options;
-    return getModeForUsageLocationWorker(file, usage, optionsForFile);
+    return getModeForUsageLocationWorker(file, usage, getCompilerOptionsForFile(file));
+  }
+  function getEmitSyntaxForUsageLocation(file, usage) {
+    return getEmitSyntaxForUsageLocationWorker(file, usage, getCompilerOptionsForFile(file));
   }
   function getModeForResolutionAtIndex2(file, index) {
     return getModeForUsageLocation2(file, getModuleNameStringLiteralAt(file, index));
   }
+  function getDefaultResolutionModeForFile2(sourceFile) {
+    return getDefaultResolutionModeForFileWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
+  }
+  function getImpliedNodeFormatForEmit2(sourceFile) {
+    return getImpliedNodeFormatForEmitWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
+  }
+  function getEmitModuleFormatOfFile2(sourceFile) {
+    return getEmitModuleFormatOfFileWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
+  }
+  function shouldTransformImportCall(sourceFile) {
+    return shouldTransformImportCallWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
+  }
+}
+function shouldTransformImportCallWorker(sourceFile, options) {
+  const moduleKind = getEmitModuleKind(options);
+  if (100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */ || moduleKind === 200 /* Preserve */) {
+    return false;
+  }
+  return getEmitModuleFormatOfFileWorker(sourceFile, options) < 5 /* ES2015 */;
+}
+function getEmitModuleFormatOfFileWorker(sourceFile, options) {
+  return getImpliedNodeFormatForEmitWorker(sourceFile, options) ?? getEmitModuleKind(options);
+}
+function getImpliedNodeFormatForEmitWorker(sourceFile, options) {
+  var _a, _b;
+  const moduleKind = getEmitModuleKind(options);
+  if (100 /* Node16 */ <= moduleKind && moduleKind <= 199 /* NodeNext */) {
+    return sourceFile.impliedNodeFormat;
+  }
+  if (sourceFile.impliedNodeFormat === 1 /* CommonJS */ && (((_a = sourceFile.packageJsonScope) == null ? void 0 : _a.contents.packageJsonContent.type) === "commonjs" || fileExtensionIsOneOf(sourceFile.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */]))) {
+    return 1 /* CommonJS */;
+  }
+  if (sourceFile.impliedNodeFormat === 99 /* ESNext */ && (((_b = sourceFile.packageJsonScope) == null ? void 0 : _b.contents.packageJsonContent.type) === "module" || fileExtensionIsOneOf(sourceFile.fileName, [".mjs" /* Mjs */, ".mts" /* Mts */]))) {
+    return 99 /* ESNext */;
+  }
+  return void 0;
+}
+function getDefaultResolutionModeForFileWorker(sourceFile, options) {
+  return importSyntaxAffectsModuleResolution(options) ? getImpliedNodeFormatForEmitWorker(sourceFile, options) : void 0;
 }
 function updateHostForUseSourceOfProjectReferenceRedirect(host) {
   let setOfDeclarationDirectories;
@@ -127124,9 +127276,15 @@ function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLoo
   const nodeModulesIndex = failedLookupPathComponents.indexOf("node_modules");
   if (nodeModulesIndex !== -1 && nodeModulesIndex + 1 <= perceivedOsRootLength + 1)
     return void 0;
+  const lastNodeModulesIndex = failedLookupPathComponents.lastIndexOf("node_modules");
   if (isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) {
     if (failedLookupPathComponents.length > rootPathComponents.length + 1) {
-      return getDirectoryOfFailedLookupWatch(failedLookupComponents, failedLookupPathComponents, Math.max(rootPathComponents.length + 1, perceivedOsRootLength + 1));
+      return getDirectoryOfFailedLookupWatch(
+        failedLookupComponents,
+        failedLookupPathComponents,
+        Math.max(rootPathComponents.length + 1, perceivedOsRootLength + 1),
+        lastNodeModulesIndex
+      );
     } else {
       return {
         dir: rootDir,
@@ -127141,12 +127299,18 @@ function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLoo
     failedLookupPathComponents.length - 1,
     perceivedOsRootLength,
     nodeModulesIndex,
-    rootPathComponents
+    rootPathComponents,
+    lastNodeModulesIndex
   );
 }
-function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dirPathComponents, dirPathComponentsLength, perceivedOsRootLength, nodeModulesIndex, rootPathComponents) {
+function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dirPathComponents, dirPathComponentsLength, perceivedOsRootLength, nodeModulesIndex, rootPathComponents, lastNodeModulesIndex) {
   if (nodeModulesIndex !== -1) {
-    return getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, nodeModulesIndex + 1);
+    return getDirectoryOfFailedLookupWatch(
+      dirComponents,
+      dirPathComponents,
+      nodeModulesIndex + 1,
+      lastNodeModulesIndex
+    );
   }
   let nonRecursive = true;
   let length2 = dirPathComponentsLength;
@@ -127157,13 +127321,29 @@ function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dir
       break;
     }
   }
-  return getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, nonRecursive);
+  return getDirectoryOfFailedLookupWatch(
+    dirComponents,
+    dirPathComponents,
+    length2,
+    lastNodeModulesIndex,
+    nonRecursive
+  );
 }
-function getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, nonRecursive) {
+function getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, lastNodeModulesIndex, nonRecursive) {
+  let packageDirLength;
+  if (lastNodeModulesIndex !== -1 && lastNodeModulesIndex + 1 >= length2 && lastNodeModulesIndex + 2 < dirPathComponents.length) {
+    if (!startsWith(dirPathComponents[lastNodeModulesIndex + 1], "@")) {
+      packageDirLength = lastNodeModulesIndex + 2;
+    } else if (lastNodeModulesIndex + 3 < dirPathComponents.length) {
+      packageDirLength = lastNodeModulesIndex + 3;
+    }
+  }
   return {
     dir: getPathFromPathComponents(dirComponents, length2),
     dirPath: getPathFromPathComponents(dirPathComponents, length2),
-    nonRecursive
+    nonRecursive,
+    packageDir: packageDirLength !== void 0 ? getPathFromPathComponents(dirComponents, packageDirLength) : void 0,
+    packageDirPath: packageDirLength !== void 0 ? getPathFromPathComponents(dirPathComponents, packageDirLength) : void 0
   };
 }
 function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, rootPathComponents, getCurrentDirectory, filterCustomPath) {
@@ -127178,7 +127358,8 @@ function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootP
     typeRootPathComponents.length,
     perceivedOsRootLengthForWatching(typeRootPathComponents, typeRootPathComponents.length),
     typeRootPathComponents.indexOf("node_modules"),
-    rootPathComponents
+    rootPathComponents,
+    typeRootPathComponents.lastIndexOf("node_modules")
   );
   return toWatch && filterCustomPath(toWatch.dirPath) ? toWatch.dirPath : void 0;
 }
@@ -127277,6 +127458,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   const rootDir = getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory);
   const rootPath = resolutionHost.toPath(rootDir);
   const rootPathComponents = getPathComponents(rootPath);
+  const isSymlinkCache = /* @__PURE__ */ new Map();
+  const packageDirWatchers = /* @__PURE__ */ new Map();
+  const dirPathToSymlinkPackageRefCount = /* @__PURE__ */ new Map();
   const typeRootsWatches = /* @__PURE__ */ new Map();
   return {
     rootDirForResolution,
@@ -127288,6 +127472,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolutionsWithOnlyAffectingLocations,
     directoryWatchesOfFailedLookups,
     fileWatchesOfAffectingLocations,
+    packageDirWatchers,
+    dirPathToSymlinkPackageRefCount,
     watchFailedLookupLocationsOfExternalModuleResolutions,
     getModuleResolutionCache: () => moduleResolutionCache,
     startRecordingFilesWithChangedResolutions,
@@ -127322,6 +127508,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function clear2() {
     clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
     clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
+    isSymlinkCache.clear();
+    packageDirWatchers.clear();
+    dirPathToSymlinkPackageRefCount.clear();
     nonRelativeExternalModuleResolutions.clear();
     closeTypeRootsWatch();
     resolvedModuleNames.clear();
@@ -127388,6 +127577,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     libraryResolutionCache.clearAllExceptPackageJsonInfoCache();
     nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
     nonRelativeExternalModuleResolutions.clear();
+    isSymlinkCache.clear();
   }
   function cleanupLibResolutionWatching(newProgram) {
     resolvedLibraries.forEach((resolution, libFileName) => {
@@ -127440,11 +127630,18 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     }
     directoryWatchesOfFailedLookups.forEach(closeDirectoryWatchesOfFailedLookup);
     fileWatchesOfAffectingLocations.forEach(closeFileWatcherOfAffectingLocation);
+    packageDirWatchers.forEach(closePackageDirWatcher);
     hasChangedAutomaticTypeDirectiveNames = false;
     moduleResolutionCache.isReadonly = true;
     typeReferenceDirectiveResolutionCache.isReadonly = true;
     libraryResolutionCache.isReadonly = true;
     moduleResolutionCache.getPackageJsonInfoCache().isReadonly = true;
+    isSymlinkCache.clear();
+  }
+  function closePackageDirWatcher(watcher, packageDirPath) {
+    if (watcher.dirPathToWatcher.size === 0) {
+      packageDirWatchers.delete(packageDirPath);
+    }
   }
   function closeDirectoryWatchesOfFailedLookup(watcher, path) {
     if (watcher.refCount === 0) {
@@ -127694,12 +127891,13 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       getCurrentDirectory
     );
     if (toWatch) {
-      const { dir, dirPath, nonRecursive } = toWatch;
+      const { dir, dirPath, nonRecursive, packageDir, packageDirPath } = toWatch;
       if (dirPath === rootPath) {
         Debug.assert(nonRecursive);
+        Debug.assert(!packageDir);
         setAtRoot = true;
       } else {
-        setDirectoryWatcher(dir, dirPath, nonRecursive);
+        setDirectoryWatcher(dir, dirPath, packageDir, packageDirPath, nonRecursive);
       }
     }
     return setAtRoot;
@@ -127723,6 +127921,10 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       setDirectoryWatcher(
         rootDir,
         rootPath,
+        /*packageDir*/
+        void 0,
+        /*packageDirPath*/
+        void 0,
         /*nonRecursive*/
         true
       );
@@ -127823,14 +128025,68 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       ));
     }
   }
-  function setDirectoryWatcher(dir, dirPath, nonRecursive) {
-    const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
+  function createDirectoryWatcherForPackageDir(dir, dirPath, packageDir, packageDirPath, nonRecursive) {
+    Debug.assert(!nonRecursive);
+    let isSymlink = isSymlinkCache.get(packageDirPath);
+    let packageDirWatcher = packageDirWatchers.get(packageDirPath);
+    if (isSymlink === void 0) {
+      const realPath2 = resolutionHost.realpath(packageDir);
+      isSymlink = realPath2 !== packageDir && resolutionHost.toPath(realPath2) !== packageDirPath;
+      isSymlinkCache.set(packageDirPath, isSymlink);
+      if (!packageDirWatcher) {
+        packageDirWatchers.set(
+          packageDirPath,
+          packageDirWatcher = {
+            dirPathToWatcher: /* @__PURE__ */ new Map(),
+            isSymlink
+          }
+        );
+      } else if (packageDirWatcher.isSymlink !== isSymlink) {
+        packageDirWatcher.dirPathToWatcher.forEach((watcher) => {
+          removeDirectoryWatcher(
+            packageDirWatcher.isSymlink ? packageDirPath : dirPath,
+            /*syncDirWatcherRemove*/
+            false
+          );
+          watcher.watcher = createDirPathToWatcher();
+        });
+        packageDirWatcher.isSymlink = isSymlink;
+      }
+    } else {
+      Debug.assertIsDefined(packageDirWatcher);
+      Debug.assert(isSymlink === packageDirWatcher.isSymlink);
+    }
+    const forDirPath = packageDirWatcher.dirPathToWatcher.get(dirPath);
+    if (forDirPath) {
+      forDirPath.refCount++;
+    } else {
+      packageDirWatcher.dirPathToWatcher.set(dirPath, {
+        watcher: createDirPathToWatcher(),
+        refCount: 1
+      });
+      if (isSymlink)
+        dirPathToSymlinkPackageRefCount.set(dirPath, (dirPathToSymlinkPackageRefCount.get(dirPath) ?? 0) + 1);
+    }
+    function createDirPathToWatcher() {
+      return isSymlink ? createOrAddRefToDirectoryWatchOfFailedLookups(packageDir, packageDirPath, nonRecursive) : createOrAddRefToDirectoryWatchOfFailedLookups(dir, dirPath, nonRecursive);
+    }
+  }
+  function setDirectoryWatcher(dir, dirPath, packageDir, packageDirPath, nonRecursive) {
+    if (!packageDirPath || !resolutionHost.realpath) {
+      createOrAddRefToDirectoryWatchOfFailedLookups(dir, dirPath, nonRecursive);
+    } else {
+      createDirectoryWatcherForPackageDir(dir, dirPath, packageDir, packageDirPath, nonRecursive);
+    }
+  }
+  function createOrAddRefToDirectoryWatchOfFailedLookups(dir, dirPath, nonRecursive) {
+    let dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
     if (dirWatcher) {
       Debug.assert(!!nonRecursive === !!dirWatcher.nonRecursive);
       dirWatcher.refCount++;
     } else {
-      directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive });
+      directoryWatchesOfFailedLookups.set(dirPath, dirWatcher = { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive });
     }
+    return dirWatcher;
   }
   function stopWatchFailedLookupLocation(failedLookupLocation, removeAtRoot, syncDirWatcherRemove) {
     const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
@@ -127843,9 +128099,27 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       getCurrentDirectory
     );
     if (toWatch) {
-      const { dirPath } = toWatch;
+      const { dirPath, packageDirPath } = toWatch;
       if (dirPath === rootPath) {
         removeAtRoot = true;
+      } else if (packageDirPath && resolutionHost.realpath) {
+        const packageDirWatcher = packageDirWatchers.get(packageDirPath);
+        const forDirPath = packageDirWatcher.dirPathToWatcher.get(dirPath);
+        forDirPath.refCount--;
+        if (forDirPath.refCount === 0) {
+          removeDirectoryWatcher(packageDirWatcher.isSymlink ? packageDirPath : dirPath, syncDirWatcherRemove);
+          packageDirWatcher.dirPathToWatcher.delete(dirPath);
+          if (packageDirWatcher.isSymlink) {
+            const refCount = dirPathToSymlinkPackageRefCount.get(dirPath) - 1;
+            if (refCount === 0) {
+              dirPathToSymlinkPackageRefCount.delete(dirPath);
+            } else {
+              dirPathToSymlinkPackageRefCount.set(dirPath, refCount);
+            }
+          }
+          if (syncDirWatcherRemove)
+            closePackageDirWatcher(packageDirWatcher, packageDirPath);
+        }
       } else {
         removeDirectoryWatcher(dirPath, syncDirWatcherRemove);
       }
@@ -128067,7 +128341,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         rootPath,
         rootPathComponents,
         getCurrentDirectory,
-        (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2)
+        (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2) || dirPathToSymlinkPackageRefCount.has(dirPath2)
       );
       if (dirPath) {
         scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
@@ -128273,10 +128547,10 @@ function explainFiles(program, write) {
   for (const file of program.getSourceFiles()) {
     write(`${toFileName(file, relativeFileName)}`);
     (_a = reasons.get(file.path)) == null ? void 0 : _a.forEach((reason) => write(`  ${fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText}`));
-    (_b = explainIfFileIsRedirectAndImpliedFormat(file, relativeFileName)) == null ? void 0 : _b.forEach((d) => write(`  ${d.messageText}`));
+    (_b = explainIfFileIsRedirectAndImpliedFormat(file, program.getCompilerOptionsForFile(file), relativeFileName)) == null ? void 0 : _b.forEach((d) => write(`  ${d.messageText}`));
   }
 }
-function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) {
+function explainIfFileIsRedirectAndImpliedFormat(file, options, fileNameConvertor) {
   var _a;
   let result;
   if (file.path !== file.resolvedPath) {
@@ -128296,7 +128570,7 @@ function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) {
     ));
   }
   if (isExternalOrCommonJsModule(file)) {
-    switch (file.impliedNodeFormat) {
+    switch (getImpliedNodeFormatForEmitWorker(file, options)) {
       case 99 /* ESNext */:
         if (file.packageJsonScope) {
           (result ?? (result = [])).push(chainDiagnosticMessages(
@@ -134677,7 +134951,9 @@ function createModuleSpecifierResolutionHost(program, host) {
     isSourceOfProjectReferenceRedirect: (fileName) => program.isSourceOfProjectReferenceRedirect(fileName),
     getNearestAncestorDirectoryWithPackageJson: maybeBind(host, host.getNearestAncestorDirectoryWithPackageJson),
     getFileIncludeReasons: () => program.getFileIncludeReasons(),
-    getCommonSourceDirectory: () => program.getCommonSourceDirectory()
+    getCommonSourceDirectory: () => program.getCommonSourceDirectory(),
+    getDefaultResolutionModeForFile: (file) => program.getDefaultResolutionModeForFile(file),
+    getModeForResolutionAtIndex: (file, index) => program.getModeForResolutionAtIndex(file, index)
   };
 }
 function getModuleSpecifierResolverHost(program, host) {
@@ -135989,9 +136265,13 @@ function fileShouldUseJavaScriptRequire(file, program, host, preferRequire) {
   if (!hasJSFileExtension(fileName)) {
     return false;
   }
-  const compilerOptions = program.getCompilerOptions();
+  const compilerOptions = typeof file === "string" ? program.getCompilerOptions() : program.getCompilerOptionsForFile(file);
   const moduleKind = getEmitModuleKind(compilerOptions);
-  const impliedNodeFormat = typeof file === "string" ? getImpliedNodeFormatForFile(toPath(file, host.getCurrentDirectory(), hostGetCanonicalFileName(host)), (_a = program.getPackageJsonInfoCache) == null ? void 0 : _a.call(program), host, compilerOptions) : file.impliedNodeFormat;
+  const sourceFileLike = typeof file === "string" ? {
+    fileName: file,
+    impliedNodeFormat: getImpliedNodeFormatForFile(toPath(file, host.getCurrentDirectory(), hostGetCanonicalFileName(host)), (_a = program.getPackageJsonInfoCache) == null ? void 0 : _a.call(program), host, compilerOptions)
+  } : file;
+  const impliedNodeFormat = getImpliedNodeFormatForEmitWorker(sourceFileLike, compilerOptions);
   if (impliedNodeFormat === 99 /* ESNext */) {
     return false;
   }
@@ -139028,7 +139308,7 @@ function computeSuggestionDiagnostics(sourceFile, program, cancellationToken) {
   program.getSemanticDiagnostics(sourceFile, cancellationToken);
   const diags = [];
   const checker = program.getTypeChecker();
-  const isCommonJSFile = sourceFile.impliedNodeFormat === 1 /* CommonJS */ || fileExtensionIsOneOf(sourceFile.fileName, [".cts" /* Cts */, ".cjs" /* Cjs */]);
+  const isCommonJSFile = program.getImpliedNodeFormatForEmit(sourceFile) === 1 /* CommonJS */ || fileExtensionIsOneOf(sourceFile.fileName, [".cts" /* Cts */, ".cjs" /* Cjs */]);
   if (!isCommonJSFile && sourceFile.commonJsModuleIndicator && (programContainsEsModules(program) || compilerOptionsIndicateEsModules(program.getCompilerOptions())) && containsTopLevelCommonjs(sourceFile)) {
     diags.push(createDiagnosticForNode(getErrorNodeFromCommonJsIndicator(sourceFile.commonJsModuleIndicator), Diagnostics.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module));
   }
@@ -152310,7 +152590,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         compilerOptions,
         createModuleSpecifierResolutionHost(program, host)
       );
-      const importKind = getImportKind(futureExportingSourceFile, exportKind, compilerOptions);
+      const importKind = getImportKind(futureExportingSourceFile, exportKind, program);
       const addAsTypeOnly = getAddAsTypeOnly(
         isImportUsageValidAsTypeOnly,
         /*isForNewImportDeclaration*/
@@ -152643,7 +152923,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
 }
 function createImportSpecifierResolver(importingFile, program, host, preferences) {
   const packageJsonImportFilter = createPackageJsonImportFilter(importingFile, preferences, host);
-  const importMap = createExistingImportMap(program.getTypeChecker(), importingFile, program.getCompilerOptions());
+  const importMap = createExistingImportMap(importingFile, program);
   return { getModuleSpecifierForBestExportInfo };
   function getModuleSpecifierForBestExportInfo(exportInfo, position, isValidTypeOnlyUseSite, fromCacheOnly) {
     const { fixes, computedWithoutCacheCount } = getImportFixes(
@@ -152750,7 +153030,7 @@ function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program
 function isFutureSymbolExportInfoArray(info) {
   return info[0].symbol === void 0;
 }
-function getImportFixes(exportInfos, usagePosition, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap = isFullSourceFile(sourceFile) ? createExistingImportMap(program.getTypeChecker(), sourceFile, program.getCompilerOptions()) : void 0, fromCacheOnly) {
+function getImportFixes(exportInfos, usagePosition, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap = isFullSourceFile(sourceFile) ? createExistingImportMap(sourceFile, program) : void 0, fromCacheOnly) {
   const checker = program.getTypeChecker();
   const existingImports = importMap && !isFutureSymbolExportInfoArray(exportInfos) ? flatMap(exportInfos, importMap.getImportsForExportInfo) : emptyArray;
   const useNamespace = usagePosition !== void 0 && tryUseExistingNamespaceImport(existingImports, usagePosition);
@@ -152866,7 +153146,8 @@ function tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker
     };
   }
 }
-function createExistingImportMap(checker, importingFile, compilerOptions) {
+function createExistingImportMap(importingFile, program) {
+  const checker = program.getTypeChecker();
   let importMap;
   for (const moduleSpecifier of importingFile.imports) {
     const i = importFromModuleSpecifier(moduleSpecifier);
@@ -152889,7 +153170,7 @@ function createExistingImportMap(checker, importingFile, compilerOptions) {
         return emptyArray;
       if (isSourceFileJS(importingFile) && !(targetFlags & 111551 /* Value */) && !every(matchingDeclarations, isJSDocImportTag))
         return emptyArray;
-      const importKind = getImportKind(importingFile, exportKind, compilerOptions);
+      const importKind = getImportKind(importingFile, exportKind, program);
       return matchingDeclarations.map((declaration) => ({ declaration, importKind, symbol, targetFlags }));
     }
   };
@@ -152906,9 +153187,9 @@ function shouldUseRequire(sourceFile, program) {
   if (compilerOptions.configFile) {
     return getEmitModuleKind(compilerOptions) < 5 /* ES2015 */;
   }
-  if (sourceFile.impliedNodeFormat === 1 /* CommonJS */)
+  if (getImpliedNodeFormatForEmit(sourceFile, program) === 1 /* CommonJS */)
     return true;
-  if (sourceFile.impliedNodeFormat === 99 /* ESNext */)
+  if (getImpliedNodeFormatForEmit(sourceFile, program) === 99 /* ESNext */)
     return false;
   for (const otherFile of program.getSourceFiles()) {
     if (otherFile === sourceFile || !isSourceFileJS(otherFile) || program.isSourceFileFromExternalLibrary(otherFile))
@@ -152965,7 +153246,7 @@ function getNewImportFixes(program, sourceFile, usagePosition, isValidTypeOnlyUs
       if (!importedSymbolHasValueMeaning && isJs && usagePosition !== void 0) {
         return { kind: 1 /* JsdocTypeImport */, moduleSpecifier, usagePosition, exportInfo: exportInfo2, isReExport: i > 0 };
       }
-      const importKind = getImportKind(sourceFile, exportInfo2.exportKind, compilerOptions);
+      const importKind = getImportKind(sourceFile, exportInfo2.exportKind, program);
       let qualification;
       if (usagePosition !== void 0 && importKind === 3 /* CommonJS */ && exportInfo2.exportKind === 0 /* Named */) {
         const exportEquals = checker.resolveExternalModuleSymbol(exportInfo2.moduleSymbol);
@@ -153138,8 +153419,8 @@ function getUmdSymbol(token, checker) {
   }
   return void 0;
 }
-function getImportKind(importingFile, exportKind, compilerOptions, forceImportKeyword) {
-  if (compilerOptions.verbatimModuleSyntax && (getEmitModuleKind(compilerOptions) === 1 /* CommonJS */ || importingFile.impliedNodeFormat === 1 /* CommonJS */)) {
+function getImportKind(importingFile, exportKind, program, forceImportKeyword) {
+  if (program.getCompilerOptions().verbatimModuleSyntax && getEmitModuleFormatOfFile(importingFile, program) === 1 /* CommonJS */) {
     return 3 /* CommonJS */;
   }
   switch (exportKind) {
@@ -153148,18 +153429,18 @@ function getImportKind(importingFile, exportKind, compilerOptions, forceImportKe
     case 1 /* Default */:
       return 1 /* Default */;
     case 2 /* ExportEquals */:
-      return getExportEqualsImportKind(importingFile, compilerOptions, !!forceImportKeyword);
+      return getExportEqualsImportKind(importingFile, program.getCompilerOptions(), !!forceImportKeyword);
     case 3 /* UMD */:
-      return getUmdImportKind(importingFile, compilerOptions, !!forceImportKeyword);
+      return getUmdImportKind(importingFile, program, !!forceImportKeyword);
     default:
       return Debug.assertNever(exportKind);
   }
 }
-function getUmdImportKind(importingFile, compilerOptions, forceImportKeyword) {
-  if (getAllowSyntheticDefaultImports(compilerOptions)) {
+function getUmdImportKind(importingFile, program, forceImportKeyword) {
+  if (getAllowSyntheticDefaultImports(program.getCompilerOptions())) {
     return 1 /* Default */;
   }
-  const moduleKind = getEmitModuleKind(compilerOptions);
+  const moduleKind = getEmitModuleKind(program.getCompilerOptions());
   switch (moduleKind) {
     case 2 /* AMD */:
     case 1 /* CommonJS */:
@@ -153178,7 +153459,7 @@ function getUmdImportKind(importingFile, compilerOptions, forceImportKeyword) {
       return 2 /* Namespace */;
     case 100 /* Node16 */:
     case 199 /* NodeNext */:
-      return importingFile.impliedNodeFormat === 99 /* ESNext */ ? 2 /* Namespace */ : 3 /* CommonJS */;
+      return getImpliedNodeFormatForEmit(importingFile, program) === 99 /* ESNext */ ? 2 /* Namespace */ : 3 /* CommonJS */;
     default:
       return Debug.assertNever(moduleKind, `Unexpected moduleKind ${moduleKind}`);
   }
@@ -153695,6 +153976,12 @@ function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitali
   }
   return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
 }
+function getImpliedNodeFormatForEmit(file, program) {
+  return isFullSourceFile(file) ? program.getImpliedNodeFormatForEmit(file) : getImpliedNodeFormatForEmitWorker(file, program.getCompilerOptions());
+}
+function getEmitModuleFormatOfFile(file, program) {
+  return isFullSourceFile(file) ? program.getEmitModuleFormatOfFile(file) : getEmitModuleFormatOfFileWorker(file, program.getCompilerOptions());
+}
 
 // src/services/codefixes/fixAddMissingConstraint.ts
 var fixId17 = "addMissingConstraint";
@@ -160222,10 +160509,12 @@ function getJSDocParamAnnotation(paramName, initializer, dotDotDotToken, isJs, i
             const printer = isSnippet ? createSnippetPrinter({
               removeComments: true,
               module: options.module,
+              moduleResolution: options.moduleResolution,
               target: options.target
             }) : createPrinter({
               removeComments: true,
               module: options.module,
+              moduleResolution: options.moduleResolution,
               target: options.target
             });
             setEmitFlags(typeNode, 1 /* SingleLine */);
@@ -160475,6 +160764,7 @@ function getExhaustiveCaseSnippets(caseBlock, sourceFile, preferences, options,
     const printer = createSnippetPrinter({
       removeComments: true,
       module: options.module,
+      moduleResolution: options.moduleResolution,
       target: options.target,
       newLine: getNewLineKind(newLineChar)
     });
@@ -160663,7 +160953,7 @@ function createCompletionEntry(symbol, sortText, replacementToken, contextToken,
   if (originIsResolvedExport(origin)) {
     sourceDisplay = [textPart(origin.moduleSpecifier)];
     if (importStatementCompletion) {
-      ({ insertText, replacementSpan } = getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences));
+      ({ insertText, replacementSpan } = getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, program, preferences));
       isSnippet = preferences.includeCompletionsWithSnippetText ? true : void 0;
     }
   }
@@ -160779,6 +161069,7 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
   const printer = createSnippetPrinter({
     removeComments: true,
     module: options.module,
+    moduleResolution: options.moduleResolution,
     target: options.target,
     omitTrailingSemicolon: false,
     newLine: getNewLineKind(getNewLineOrDefaultFromHost(host, formatContext == null ? void 0 : formatContext.options))
@@ -160929,6 +161220,7 @@ function getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclara
   const printer = createSnippetPrinter({
     removeComments: true,
     module: options.module,
+    moduleResolution: options.moduleResolution,
     target: options.target,
     omitTrailingSemicolon: false,
     newLine: getNewLineKind(getNewLineOrDefaultFromHost(host, formatContext == null ? void 0 : formatContext.options))
@@ -160949,6 +161241,7 @@ function getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclara
   const signaturePrinter = createPrinter({
     removeComments: true,
     module: options.module,
+    moduleResolution: options.moduleResolution,
     target: options.target,
     omitTrailingSemicolon: true
   });
@@ -161210,7 +161503,7 @@ function completionEntryDataToSymbolOriginInfo(data, completionName, moduleSymbo
   };
   return unresolvedOrigin;
 }
-function getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences) {
+function getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, program, preferences) {
   const replacementSpan = importStatementCompletion.replacementSpan;
   const quotedModuleSpecifier = escapeSnippetText(quote(sourceFile, preferences, origin.moduleSpecifier));
   const exportKind = origin.isDefaultExport ? 1 /* Default */ : origin.exportName === "export=" /* ExportEquals */ ? 2 /* ExportEquals */ : 0 /* Named */;
@@ -161218,7 +161511,7 @@ function getInsertTextAndReplacementSpanForImportCompletion(name, importStatemen
   const importKind = ts_codefix_exports.getImportKind(
     sourceFile,
     exportKind,
-    options,
+    program,
     /*forceImportKeyword*/
     true
   );
@@ -163634,7 +163927,7 @@ function createNameAndKindSet() {
 }
 function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences, includeSymbol) {
   if (isInReferenceComment(sourceFile, position)) {
-    const entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host);
+    const entries = getTripleSlashReferenceCompletion(sourceFile, position, program, host);
     return entries && convertPathCompletions(entries);
   }
   if (isInString(sourceFile, position, contextToken)) {
@@ -163947,7 +164240,7 @@ function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, prog
   const compilerOptions = program.getCompilerOptions();
   const typeChecker = program.getTypeChecker();
   const extensionOptions = getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile, typeChecker, preferences, mode);
-  return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && !compilerOptions.paths && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, compilerOptions, host, extensionOptions, typeChecker);
+  return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && !compilerOptions.paths && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, program, host, extensionOptions);
 }
 function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile, typeChecker, preferences, resolutionMode) {
   return {
@@ -163958,14 +164251,15 @@ function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile
     resolutionMode
   };
 }
-function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, extensionOptions) {
+function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, scriptPath, extensionOptions) {
+  const compilerOptions = program.getCompilerOptions();
   if (compilerOptions.rootDirs) {
     return getCompletionEntriesForDirectoryFragmentWithRootDirs(
       compilerOptions.rootDirs,
       literalValue,
       scriptDirectory,
       extensionOptions,
-      compilerOptions,
+      program,
       host,
       scriptPath
     );
@@ -163974,6 +164268,7 @@ function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, c
       literalValue,
       scriptDirectory,
       extensionOptions,
+      program,
       host,
       /*moduleSpecifierIsRelative*/
       true,
@@ -164001,7 +164296,8 @@ function getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ign
     compareStringsCaseSensitive
   );
 }
-function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, compilerOptions, host, exclude) {
+function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, program, host, exclude) {
+  const compilerOptions = program.getCompilerOptions();
   const basePath = compilerOptions.project || host.getCurrentDirectory();
   const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
   const baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase);
@@ -164010,6 +164306,7 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment
       fragment,
       baseDirectory,
       extensionOptions,
+      program,
       host,
       /*moduleSpecifierIsRelative*/
       true,
@@ -164018,7 +164315,7 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment
     (itemA, itemB) => itemA.name === itemB.name && itemA.kind === itemB.kind && itemA.extension === itemB.extension
   );
 }
-function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, host, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) {
+function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) {
   var _a;
   if (fragment === void 0) {
     fragment = "";
@@ -164043,7 +164340,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext
         if (versionPaths) {
           const packageDirectory = getDirectoryPath(packageJsonPath);
           const pathInPackage = absolutePath.slice(ensureTrailingDirectorySeparator(packageDirectory).length);
-          if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, host, versionPaths)) {
+          if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, program, host, versionPaths)) {
             return result;
           }
         }
@@ -164070,7 +164367,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext
       }
       const { name, extension } = getFilenameWithExtensionOption(
         getBaseFileName(filePath),
-        host.getCompilationSettings(),
+        program,
         extensionOptions,
         /*isExportsWildcard*/
         false
@@ -164089,7 +164386,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext
   }
   return result;
 }
-function getFilenameWithExtensionOption(name, compilerOptions, extensionOptions, isExportsWildcard) {
+function getFilenameWithExtensionOption(name, program, extensionOptions, isExportsWildcard) {
   const nonJsResult = ts_moduleSpecifiers_exports.tryGetRealFileNameForNonJsDeclarationFileName(name);
   if (nonJsResult) {
     return { name: nonJsResult, extension: tryGetExtensionFromPath2(nonJsResult) };
@@ -164099,7 +164396,8 @@ function getFilenameWithExtensionOption(name, compilerOptions, extensionOptions,
   }
   let allowedEndings = getModuleSpecifierPreferences(
     { importModuleSpecifierEnding: extensionOptions.endingPreference },
-    compilerOptions,
+    program,
+    program.getCompilerOptions(),
     extensionOptions.importingSourceFile
   ).getAllowedEndingsInPreferredOrder(extensionOptions.resolutionMode);
   if (isExportsWildcard) {
@@ -164109,16 +164407,16 @@ function getFilenameWithExtensionOption(name, compilerOptions, extensionOptions,
     if (fileExtensionIsOneOf(name, supportedTSImplementationExtensions)) {
       return { name, extension: tryGetExtensionFromPath2(name) };
     }
-    const outputExtension2 = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, compilerOptions);
+    const outputExtension2 = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, program.getCompilerOptions());
     return outputExtension2 ? { name: changeExtension(name, outputExtension2), extension: outputExtension2 } : { name, extension: tryGetExtensionFromPath2(name) };
   }
   if (!isExportsWildcard && (allowedEndings[0] === 0 /* Minimal */ || allowedEndings[0] === 1 /* Index */) && fileExtensionIsOneOf(name, [".js" /* Js */, ".jsx" /* Jsx */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */])) {
     return { name: removeFileExtension(name), extension: tryGetExtensionFromPath2(name) };
   }
-  const outputExtension = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, compilerOptions);
+  const outputExtension = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, program.getCompilerOptions());
   return outputExtension ? { name: changeExtension(name, outputExtension), extension: outputExtension } : { name, extension: tryGetExtensionFromPath2(name) };
 }
-function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, host, paths) {
+function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, program, host, paths) {
   const getPatternsForKey = (key) => paths[key];
   const comparePaths2 = (a, b) => {
     const patternA = tryParsePattern(a);
@@ -164134,13 +164432,14 @@ function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensio
     fragment,
     baseDirectory,
     extensionOptions,
+    program,
     host,
     getOwnKeys(paths),
     getPatternsForKey,
     comparePaths2
   );
 }
-function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, baseDirectory, extensionOptions, host, keys, getPatternsForKey, comparePaths2) {
+function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, baseDirectory, extensionOptions, program, host, keys, getPatternsForKey, comparePaths2) {
   let pathResults = [];
   let matchedPath;
   for (const key of keys) {
@@ -164161,7 +164460,7 @@ function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, bas
       if (typeof pathPattern === "string" || matchedPath === void 0 || comparePaths2(key, matchedPath) !== 1 /* GreaterThan */) {
         pathResults.push({
           matchedPattern: isMatch,
-          results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, isExports && isMatch, host).map(({ name, kind, extension }) => nameAndKind(name, kind, extension))
+          results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, isExports && isMatch, program, host).map(({ name, kind, extension }) => nameAndKind(name, kind, extension))
         });
       }
     }
@@ -164169,7 +164468,9 @@ function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, bas
   pathResults.forEach((pathResult) => pathResult.results.forEach((r) => result.add(r)));
   return matchedPath !== void 0;
 }
-function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, compilerOptions, host, extensionOptions, typeChecker) {
+function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, program, host, extensionOptions) {
+  const typeChecker = program.getTypeChecker();
+  const compilerOptions = program.getCompilerOptions();
   const { baseUrl, paths } = compilerOptions;
   const result = createNameAndKindSet();
   const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
@@ -164179,6 +164480,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c
       fragment,
       absolute,
       extensionOptions,
+      program,
       host,
       /*moduleSpecifierIsRelative*/
       false,
@@ -164189,7 +164491,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c
   }
   if (paths) {
     const absolute = getPathsBasePath(compilerOptions, host);
-    addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, host, paths);
+    addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, program, host, paths);
   }
   const fragmentDirectory = getFragmentDirectory(fragment);
   for (const ambientName of getAmbientModuleCompletions(fragment, fragmentDirectory, typeChecker)) {
@@ -164200,7 +164502,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c
       void 0
     ));
   }
-  getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, fragmentDirectory, extensionOptions, result);
+  getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDirectory, extensionOptions, result);
   if (moduleResolutionUsesNodeModules(moduleResolution)) {
     let foundGlobal = false;
     if (fragmentDirectory === void 0) {
@@ -164225,6 +164527,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c
             fragment,
             nodeModules,
             extensionOptions,
+            program,
             host,
             /*moduleSpecifierIsRelative*/
             false,
@@ -164269,6 +164572,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c
                 fragmentSubpath,
                 packageDirectory,
                 extensionOptions,
+                program,
                 host,
                 keys,
                 (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports2[key], conditions)),
@@ -164301,7 +164605,7 @@ function getPatternFromFirstMatchingCondition(target, conditions) {
 function getFragmentDirectory(fragment) {
   return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
 }
-function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, isExportsWildcard, host) {
+function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, isExportsWildcard, program, host) {
   if (!endsWith(path, "*")) {
     return !path.includes("*") ? justPathMappingName(path, "script" /* scriptElement */) : emptyArray;
   }
@@ -164311,15 +164615,15 @@ function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory
     const starIsFullPathComponent = path[path.length - 2] === "/";
     return starIsFullPathComponent ? justPathMappingName(pathPrefix, "directory" /* directory */) : flatMap(patterns, (pattern) => {
       var _a;
-      return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, isExportsWildcard, host)) == null ? void 0 : _a.map(({ name, ...rest }) => ({ name: pathPrefix + name, ...rest }));
+      return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host)) == null ? void 0 : _a.map(({ name, ...rest }) => ({ name: pathPrefix + name, ...rest }));
     });
   }
-  return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, host));
+  return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host));
   function justPathMappingName(name, kind) {
     return startsWith(name, fragment) ? [{ name: removeTrailingDirectorySeparator(name), kind, extension: void 0 }] : emptyArray;
   }
 }
-function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, host) {
+function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host) {
   if (!host.readDirectory) {
     return void 0;
   }
@@ -164352,7 +164656,7 @@ function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensio
       if (containsSlash(trimmedWithPattern)) {
         return directoryResult(getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]);
       }
-      const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, host.getCompilationSettings(), extensionOptions, isExportsWildcard);
+      const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, program, extensionOptions, isExportsWildcard);
       return nameAndKind(name, "script" /* scriptElement */, extension);
     }
   });
@@ -164380,7 +164684,8 @@ function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
   }
   return nonRelativeModuleNames;
 }
-function getTripleSlashReferenceCompletion(sourceFile, position, compilerOptions, host) {
+function getTripleSlashReferenceCompletion(sourceFile, position, program, host) {
+  const compilerOptions = program.getCompilerOptions();
   const token = getTokenAtPosition(sourceFile, position);
   const commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos);
   const range = commentRanges && find(commentRanges, (commentRange) => position >= commentRange.pos && position <= commentRange.end);
@@ -164398,14 +164703,16 @@ function getTripleSlashReferenceCompletion(sourceFile, position, compilerOptions
     toComplete,
     scriptPath,
     getExtensionOptions(compilerOptions, 0 /* Filename */, sourceFile),
+    program,
     host,
     /*moduleSpecifierIsRelative*/
     true,
     sourceFile.path
-  ) : kind === "types" ? getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile)) : Debug.fail();
+  ) : kind === "types" ? getCompletionEntriesFromTypings(host, program, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile)) : Debug.fail();
   return addReplacementSpans(toComplete, range.pos + prefix.length, arrayFrom(names.values()));
 }
-function getCompletionEntriesFromTypings(host, options, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
+function getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
+  const options = program.getCompilerOptions();
   const seen = /* @__PURE__ */ new Map();
   const typeRoots = tryAndIgnoreErrors(() => getEffectiveTypeRoots(options, host)) || emptyArray;
   for (const root of typeRoots) {
@@ -164441,6 +164748,7 @@ function getCompletionEntriesFromTypings(host, options, scriptPath, fragmentDire
             remainingFragment,
             baseDirectory,
             extensionOptions,
+            program,
             host,
             /*moduleSpecifierIsRelative*/
             false,
@@ -164827,7 +165135,7 @@ function findModuleReferences(program, sourceFiles, searchModuleSymbol) {
         }
       }
       for (const ref of referencingFile.typeReferenceDirectives) {
-        const referenced = (_a = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat)) == null ? void 0 : _a.resolvedTypeReferenceDirective;
+        const referenced = (_a = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || program.getDefaultResolutionModeForFile(referencingFile))) == null ? void 0 : _a.resolvedTypeReferenceDirective;
         if (referenced !== void 0 && referenced.resolvedFileName === searchSourceFile.fileName) {
           refs.push({ kind: "reference", referencingFile, ref });
         }
@@ -167190,7 +167498,7 @@ function getReferenceAtPosition(sourceFile, position, program) {
   }
   const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
   if (typeReferenceDirective) {
-    const reference = (_a = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat)) == null ? void 0 : _a.resolvedTypeReferenceDirective;
+    const reference = (_a = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || program.getDefaultResolutionModeForFile(sourceFile))) == null ? void 0 : _a.resolvedTypeReferenceDirective;
     const file = reference && program.getSourceFile(reference.resolvedFileName);
     return file && { reference: typeReferenceDirective, fileName: file.fileName, file, unverified: false };
   }
@@ -175636,6 +175944,7 @@ __export(ts_exports2, {
   canHaveJSDoc: () => canHaveJSDoc,
   canHaveLocals: () => canHaveLocals,
   canHaveModifiers: () => canHaveModifiers,
+  canHaveModuleSpecifier: () => canHaveModuleSpecifier,
   canHaveSymbol: () => canHaveSymbol,
   canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
   canProduceDiagnostics: () => canProduceDiagnostics,
@@ -176102,6 +176411,7 @@ __export(ts_exports2, {
   getDefaultLibFileName: () => getDefaultLibFileName,
   getDefaultLibFilePath: () => getDefaultLibFilePath,
   getDefaultLikeExportInfo: () => getDefaultLikeExportInfo,
+  getDefaultResolutionModeForFileWorker: () => getDefaultResolutionModeForFileWorker,
   getDiagnosticText: () => getDiagnosticText,
   getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan,
   getDirectoryPath: () => getDirectoryPath,
@@ -176132,6 +176442,7 @@ __export(ts_exports2, {
   getEmitFlags: () => getEmitFlags,
   getEmitHelpers: () => getEmitHelpers,
   getEmitModuleDetectionKind: () => getEmitModuleDetectionKind,
+  getEmitModuleFormatOfFileWorker: () => getEmitModuleFormatOfFileWorker,
   getEmitModuleKind: () => getEmitModuleKind,
   getEmitModuleResolutionKind: () => getEmitModuleResolutionKind,
   getEmitScriptTarget: () => getEmitScriptTarget,
@@ -176182,6 +176493,7 @@ __export(ts_exports2, {
   getIdentifierGeneratedImportReference: () => getIdentifierGeneratedImportReference,
   getIdentifierTypeArguments: () => getIdentifierTypeArguments,
   getImmediatelyInvokedFunctionExpression: () => getImmediatelyInvokedFunctionExpression,
+  getImpliedNodeFormatForEmitWorker: () => getImpliedNodeFormatForEmitWorker,
   getImpliedNodeFormatForFile: () => getImpliedNodeFormatForFile,
   getImpliedNodeFormatForFileWorker: () => getImpliedNodeFormatForFileWorker,
   getImportNeedsImportDefaultHelper: () => getImportNeedsImportDefaultHelper,
@@ -176537,6 +176849,7 @@ __export(ts_exports2, {
   importDefaultHelper: () => importDefaultHelper,
   importFromModuleSpecifier: () => importFromModuleSpecifier,
   importStarHelper: () => importStarHelper,
+  importSyntaxAffectsModuleResolution: () => importSyntaxAffectsModuleResolution,
   indexOfAnyCharCode: () => indexOfAnyCharCode,
   indexOfNode: () => indexOfNode,
   indicesOf: () => indicesOf,
@@ -177626,11 +177939,11 @@ __export(ts_exports2, {
   transformESDecorators: () => transformESDecorators,
   transformESNext: () => transformESNext,
   transformGenerators: () => transformGenerators,
+  transformImpliedNodeFormatDependentModule: () => transformImpliedNodeFormatDependentModule,
   transformJsx: () => transformJsx,
   transformLegacyDecorators: () => transformLegacyDecorators,
   transformModule: () => transformModule,
   transformNamedEvaluation: () => transformNamedEvaluation,
-  transformNodeModule: () => transformNodeModule,
   transformNodes: () => transformNodes,
   transformSystemModule: () => transformSystemModule,
   transformTypeScript: () => transformTypeScript,
@@ -177938,6 +178251,7 @@ __export(ts_server_exports3, {
   isExternalProject: () => isExternalProject,
   isInferredProject: () => isInferredProject,
   isInferredProjectName: () => isInferredProjectName,
+  isProjectDeferredClose: () => isProjectDeferredClose,
   makeAutoImportProviderProjectName: () => makeAutoImportProviderProjectName,
   makeAuxiliaryProjectName: () => makeAuxiliaryProjectName,
   makeInferredProjectName: () => makeInferredProjectName,
@@ -178851,6 +179165,9 @@ var TextStorage = class {
     const reloaded = this.reload(newText);
     this.fileSize = fileSize;
     this.ownFileText = !tempFileName || tempFileName === this.info.fileName;
+    if (this.ownFileText && this.info.mTime === missingFileModifiedTime.getTime()) {
+      this.info.mTime = (this.host.getModifiedTime(this.info.fileName) || missingFileModifiedTime).getTime();
+    }
     return reloaded;
   }
   /**
@@ -179129,7 +179446,9 @@ var ScriptInfo = class {
       case 0:
         return Errors.ThrowNoProject();
       case 1:
-        return ensurePrimaryProjectKind(this.containingProjects[0]);
+        return ensurePrimaryProjectKind(
+          !isProjectDeferredClose(this.containingProjects[0]) ? this.containingProjects[0] : void 0
+        );
       default:
         let firstExternalProject;
         let firstConfiguredProject;
@@ -179139,6 +179458,8 @@ var ScriptInfo = class {
         for (let index = 0; index < this.containingProjects.length; index++) {
           const project = this.containingProjects[index];
           if (isConfiguredProject(project)) {
+            if (project.deferredClose)
+              continue;
             if (!project.isSourceOfProjectReferenceRedirect(this.fileName)) {
               if (defaultConfiguredProject === void 0 && index !== this.containingProjects.length - 1) {
                 defaultConfiguredProject = project.projectService.findDefaultConfiguredProject(this) || false;
@@ -179212,7 +179533,7 @@ var ScriptInfo = class {
     }
   }
   isOrphan() {
-    return !forEach(this.containingProjects, (p) => !p.isOrphan());
+    return this.deferredDelete || !forEach(this.containingProjects, (p) => !p.isOrphan());
   }
   /** @internal */
   isContainedByBackgroundProject() {
@@ -179658,7 +179979,13 @@ var Project3 = class _Project {
     return addRange(result, this.typingFiles) || emptyArray;
   }
   getOrCreateScriptInfoAndAttachToProject(fileName) {
-    const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(fileName, this.currentDirectory, this.directoryStructureHost);
+    const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(
+      fileName,
+      this.currentDirectory,
+      this.directoryStructureHost,
+      /*deferredDeleteOk*/
+      false
+    );
     if (scriptInfo) {
       const existingValue = this.rootFilesMap.get(scriptInfo.path);
       if (existingValue && existingValue.info !== scriptInfo) {
@@ -179674,7 +180001,13 @@ var Project3 = class _Project {
     return info && info.scriptKind;
   }
   getScriptVersion(filename) {
-    const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(filename, this.currentDirectory, this.directoryStructureHost);
+    const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(
+      filename,
+      this.currentDirectory,
+      this.directoryStructureHost,
+      /*deferredDeleteOk*/
+      false
+    );
     return info && info.getLatestVersion();
   }
   getScriptSnapshot(filename) {
@@ -180206,6 +180539,7 @@ var Project3 = class _Project {
       (this.changedFilesForExportMapCache || (this.changedFilesForExportMapCache = /* @__PURE__ */ new Set())).add(changedFile);
     }
   }
+  /** @internal */
   markAsDirty() {
     if (!this.dirty) {
       this.projectStateVersion++;
@@ -180506,7 +180840,13 @@ var Project3 = class _Project {
       // by the host for files in the program when the program is retrieved above but
       // the program doesn't contain external files so this must be done explicitly.
       (inserted) => {
-        const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(inserted, this.currentDirectory, this.directoryStructureHost);
+        const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(
+          inserted,
+          this.currentDirectory,
+          this.directoryStructureHost,
+          /*deferredDeleteOk*/
+          false
+        );
         scriptInfo == null ? void 0 : scriptInfo.attachToProject(this);
       },
       (removed) => this.detachScriptInfoFromProject(removed)
@@ -181336,6 +181676,7 @@ var _AutoImportProviderProject = class _AutoImportProviderProject extends Projec
   isEmpty() {
     return !some(this.rootFileNames);
   }
+  /** @internal */
   isOrphan() {
     return true;
   }
@@ -181366,6 +181707,7 @@ var _AutoImportProviderProject = class _AutoImportProviderProject extends Projec
     var _a;
     return !!((_a = this.rootFileNames) == null ? void 0 : _a.length);
   }
+  /** @internal */
   markAsDirty() {
     this.rootFileNames = void 0;
     super.markAsDirty();
@@ -181489,6 +181831,8 @@ var ConfiguredProject2 = class extends Project3 {
    * @returns: true if set of files in the project stays the same and false - otherwise.
    */
   updateGraph() {
+    if (this.deferredClose)
+      return false;
     const isInitialLoad = this.isInitialLoadPending();
     this.isInitialLoadPending = returnFalse;
     const updateLevel = this.pendingUpdateLevel;
@@ -181603,6 +181947,12 @@ var ConfiguredProject2 = class extends Project3 {
     super.close();
   }
   /** @internal */
+  markAsDirty() {
+    if (this.deferredClose)
+      return;
+    super.markAsDirty();
+  }
+  /** @internal */
   addExternalProjectReference() {
     this.externalProjectRefCount++;
   }
@@ -181633,7 +181983,7 @@ var ConfiguredProject2 = class extends Project3 {
    * @internal
    */
   hasOpenRef() {
-    var _a;
+    var _a, _b;
     if (!!this.externalProjectRefCount) {
       return true;
     }
@@ -181641,8 +181991,10 @@ var ConfiguredProject2 = class extends Project3 {
       return false;
     }
     const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(this.canonicalConfigFilePath);
-    if (this.projectService.hasPendingProjectUpdate(this)) {
+    if (this.deferredClose)
       return !!((_a = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.size);
+    if (this.projectService.hasPendingProjectUpdate(this)) {
+      return !!((_b = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _b.size);
     }
     return !!configFileExistenceInfo.openFilesImpactedByConfigFile && forEachEntry(
       configFileExistenceInfo.openFilesImpactedByConfigFile,
@@ -181658,6 +182010,10 @@ var ConfiguredProject2 = class extends Project3 {
     ) || false;
   }
   /** @internal */
+  isOrphan() {
+    return !!this.deferredClose;
+  }
+  /** @internal */
   hasExternalProjectRef() {
     return !!this.externalProjectRefCount;
   }
@@ -181712,6 +182068,9 @@ function isExternalProject(project) {
 function isBackgroundProject(project) {
   return project.projectKind === 3 /* AutoImportProvider */ || project.projectKind === 4 /* Auxiliary */;
 }
+function isProjectDeferredClose(project) {
+  return isConfiguredProject(project) && !!project.deferredClose;
+}
 
 // src/server/editorServices.ts
 var maxProgramSizeForNonTsFiles = 20 * 1024 * 1024;
@@ -182340,6 +182699,8 @@ var _ProjectService = class _ProjectService {
     );
   }
   delayUpdateProjectGraph(project) {
+    if (isProjectDeferredClose(project))
+      return;
     project.markAsDirty();
     if (isBackgroundProject(project))
       return;
@@ -182537,9 +182898,16 @@ var _ProjectService = class _ProjectService {
     return this.hostConfiguration.preferences;
   }
   onSourceFileChanged(info, eventKind) {
+    Debug.assert(!info.isScriptOpen());
     if (eventKind === 2 /* Deleted */) {
-      this.handleDeletedFile(info);
-    } else if (!info.isScriptOpen()) {
+      this.handleDeletedFile(
+        info,
+        /*deferredDelete*/
+        true
+      );
+    } else {
+      if (info.deferredDelete)
+        info.deferredDelete = void 0;
       info.delayReloadNonMixedContentFile();
       this.delayUpdateProjectGraphs(
         info.containingProjects,
@@ -182553,7 +182921,7 @@ var _ProjectService = class _ProjectService {
     if (info.sourceMapFilePath) {
       if (isString(info.sourceMapFilePath)) {
         const sourceMapFileInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
-        this.delayUpdateSourceInfoProjects(sourceMapFileInfo && sourceMapFileInfo.sourceInfos);
+        this.delayUpdateSourceInfoProjects(sourceMapFileInfo == null ? void 0 : sourceMapFileInfo.sourceInfos);
       } else {
         this.delayUpdateSourceInfoProjects(info.sourceMapFilePath.sourceInfos);
       }
@@ -182578,25 +182946,20 @@ var _ProjectService = class _ProjectService {
       );
     }
   }
-  handleDeletedFile(info) {
-    this.stopWatchingScriptInfo(info);
-    if (!info.isScriptOpen()) {
+  handleDeletedFile(info, deferredDelete) {
+    Debug.assert(!info.isScriptOpen());
+    this.delayUpdateProjectGraphs(
+      info.containingProjects,
+      /*clearSourceMapperCache*/
+      false
+    );
+    this.handleSourceMapProjects(info);
+    info.detachAllProjects();
+    if (deferredDelete) {
+      info.delayReloadNonMixedContentFile();
+      info.deferredDelete = true;
+    } else {
       this.deleteScriptInfo(info);
-      const containingProjects = info.containingProjects.slice();
-      info.detachAllProjects();
-      this.delayUpdateProjectGraphs(
-        containingProjects,
-        /*clearSourceMapperCache*/
-        false
-      );
-      this.handleSourceMapProjects(info);
-      info.closeSourceMapFileWatcher();
-      if (info.declarationInfoPath) {
-        const declarationInfo = this.getScriptInfoForPath(info.declarationInfoPath);
-        if (declarationInfo) {
-          declarationInfo.sourceMapFilePath = void 0;
-        }
-      }
     }
   }
   /**
@@ -182707,24 +183070,24 @@ var _ProjectService = class _ProjectService {
   }
   /** @internal */
   onConfigFileChanged(canonicalConfigFilePath, eventKind) {
-    var _a;
     const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
+    const project = this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath);
+    const wasDefferedClose = project == null ? void 0 : project.deferredClose;
     if (eventKind === 2 /* Deleted */) {
       configFileExistenceInfo.exists = false;
-      const project = ((_a = configFileExistenceInfo.config) == null ? void 0 : _a.projects.has(canonicalConfigFilePath)) ? this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath) : void 0;
       if (project)
-        this.removeProject(project);
+        project.deferredClose = true;
     } else {
       configFileExistenceInfo.exists = true;
+      if (wasDefferedClose) {
+        project.deferredClose = void 0;
+        project.markAsDirty();
+      }
     }
     this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalConfigFilePath, "Change in config file detected");
-    this.reloadConfiguredProjectForFiles(
-      configFileExistenceInfo.openFilesImpactedByConfigFile,
-      /*clearSemanticCache*/
-      false,
-      /*delayReload*/
-      true,
-      eventKind !== 2 /* Deleted */ ? identity : (
+    this.delayReloadConfiguredProjectsForFile(
+      configFileExistenceInfo,
+      !wasDefferedClose && eventKind !== 2 /* Deleted */ ? identity : (
         // Reload open files if they are root of inferred project
         returnTrue
       ),
@@ -182733,6 +183096,33 @@ var _ProjectService = class _ProjectService {
     );
     this.delayEnsureProjectForOpenFiles();
   }
+  /**
+   * This function goes through all the openFiles and tries to file the config file for them.
+   * If the config file is found and it refers to existing project, it schedules the reload it for reload
+   * If there is no existing project it just opens the configured project for the config file
+   * shouldReloadProjectFor provides a way to filter out files to reload configured project for
+   */
+  delayReloadConfiguredProjectsForFile(configFileExistenceInfo, shouldReloadProjectFor, reason) {
+    var _a;
+    const updatedProjects = /* @__PURE__ */ new Set();
+    (_a = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a.forEach((infoIsRootOfInferredProject, path) => {
+      this.configFileForOpenFiles.delete(path);
+      if (!shouldReloadProjectFor(infoIsRootOfInferredProject)) {
+        return;
+      }
+      const info = this.getScriptInfoForPath(path);
+      Debug.assert(info.isScriptOpen());
+      const configFileName = this.getConfigFileNameForFile(info);
+      if (configFileName) {
+        const project = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProject(configFileName);
+        if (tryAddToSet(updatedProjects, project)) {
+          project.pendingUpdateLevel = 2 /* Full */;
+          project.pendingUpdateReason = reason;
+          this.delayUpdateProjectGraph(project);
+        }
+      }
+    });
+  }
   removeProject(project) {
     this.logger.info("`remove Project::");
     project.print(
@@ -182876,17 +183266,24 @@ var _ProjectService = class _ProjectService {
     if (fileExists) {
       this.watchClosedScriptInfo(info);
     } else {
-      this.handleDeletedFile(info);
+      this.handleDeletedFile(
+        info,
+        /*deferredDelete*/
+        false
+      );
     }
     return ensureProjectsForOpenFiles;
   }
   deleteScriptInfo(info) {
+    Debug.assert(!info.isScriptOpen());
     this.filenameToScriptInfo.delete(info.path);
     this.filenameToScriptInfoVersion.set(info.path, info.textStorage.version);
+    this.stopWatchingScriptInfo(info);
     const realpath = info.getRealpathIfDifferent();
     if (realpath) {
       this.realpathToScriptInfos.remove(realpath, info);
     }
+    info.closeSourceMapFileWatcher();
   }
   configFileExists(configFileName, canonicalConfigFilePath, info) {
     var _a;
@@ -183126,7 +183523,8 @@ var _ProjectService = class _ProjectService {
   /** @internal */
   findConfiguredProjectByProjectName(configFileName) {
     const canonicalConfigFilePath = asNormalizedPath(this.toCanonicalFileName(configFileName));
-    return this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath);
+    const result = this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath);
+    return !(result == null ? void 0 : result.deferredClose) ? result : void 0;
   }
   getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath) {
     return this.configuredProjects.get(canonicalConfigFilePath);
@@ -183256,6 +183654,7 @@ var _ProjectService = class _ProjectService {
       this.documentRegistry,
       configFileExistenceInfo.config.cachedDirectoryStructureHost
     );
+    Debug.assert(!this.configuredProjects.has(canonicalConfigFilePath));
     this.configuredProjects.set(canonicalConfigFilePath, project);
     this.createConfigFileWatcherForParsedConfig(configFileName, canonicalConfigFilePath, project);
     return project;
@@ -183484,7 +183883,9 @@ var _ProjectService = class _ProjectService {
           project.currentDirectory,
           scriptKind,
           hasMixedContent,
-          project.directoryStructureHost
+          project.directoryStructureHost,
+          /*deferredDeleteOk*/
+          false
         ));
         path = scriptInfo.path;
         const existingValue = projectRootFilesMap.get(path);
@@ -183679,7 +184080,7 @@ var _ProjectService = class _ProjectService {
     return project;
   }
   /** @internal */
-  getOrCreateScriptInfoNotOpenedByClient(uncheckedFileName, currentDirectory, hostToQueryFileExistsOn) {
+  getOrCreateScriptInfoNotOpenedByClient(uncheckedFileName, currentDirectory, hostToQueryFileExistsOn, deferredDeleteOk) {
     return this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(
       toNormalizedPath(uncheckedFileName),
       currentDirectory,
@@ -183687,7 +184088,8 @@ var _ProjectService = class _ProjectService {
       void 0,
       /*hasMixedContent*/
       void 0,
-      hostToQueryFileExistsOn
+      hostToQueryFileExistsOn,
+      deferredDeleteOk
     );
   }
   getScriptInfo(uncheckedFileName) {
@@ -183704,7 +184106,13 @@ var _ProjectService = class _ProjectService {
   }
   /** @internal */
   logErrorForScriptInfoNotFound(fileName) {
-    const names = arrayFrom(this.filenameToScriptInfo.entries(), ([path, scriptInfo]) => ({ path, fileName: scriptInfo.fileName }));
+    const names = arrayFrom(
+      mapDefinedIterator(
+        this.filenameToScriptInfo.entries(),
+        (entry) => entry[1].deferredDelete ? void 0 : entry
+      ),
+      ([path, scriptInfo]) => ({ path, fileName: scriptInfo.fileName })
+    );
     this.logger.msg(`Could not find file ${JSON.stringify(fileName)}.
 All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
   }
@@ -183776,7 +184184,7 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
           if (dirPath === fileOrDirectoryPath) {
             this.refreshScriptInfosInDirectory(dirPath);
           } else {
-            const info = this.getScriptInfoForPath(fileOrDirectoryPath);
+            const info = this.filenameToScriptInfo.get(fileOrDirectoryPath);
             if (info) {
               if (isScriptInfoWatchedFromNodeModules(info)) {
                 this.refreshScriptInfo(info);
@@ -183858,7 +184266,7 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
       info.fileWatcher = void 0;
     }
   }
-  getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(fileName, currentDirectory, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
+  getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(fileName, currentDirectory, scriptKind, hasMixedContent, hostToQueryFileExistsOn, deferredDeleteOk) {
     if (isRootedDiskPath(fileName) || isDynamicFileName(fileName)) {
       return this.getOrCreateScriptInfoWorker(
         fileName,
@@ -183868,8 +184276,9 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
         /*fileContent*/
         void 0,
         scriptKind,
-        hasMixedContent,
-        hostToQueryFileExistsOn
+        !!hasMixedContent,
+        hostToQueryFileExistsOn,
+        deferredDeleteOk
       );
     }
     const info = this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(fileName));
@@ -183878,24 +184287,23 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
     }
     return void 0;
   }
-  getOrCreateScriptInfoOpenedByClientForNormalizedPath(fileName, currentDirectory, fileContent, scriptKind, hasMixedContent) {
+  getOrCreateScriptInfoForNormalizedPath(fileName, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
     return this.getOrCreateScriptInfoWorker(
       fileName,
-      currentDirectory,
-      /*openedByClient*/
-      true,
+      this.currentDirectory,
+      openedByClient,
       fileContent,
       scriptKind,
-      hasMixedContent
+      !!hasMixedContent,
+      hostToQueryFileExistsOn,
+      /*deferredDeleteOk*/
+      false
     );
   }
-  getOrCreateScriptInfoForNormalizedPath(fileName, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
-    return this.getOrCreateScriptInfoWorker(fileName, this.currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn);
-  }
-  getOrCreateScriptInfoWorker(fileName, currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
+  getOrCreateScriptInfoWorker(fileName, currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn, deferredDeleteOk) {
     Debug.assert(fileContent === void 0 || openedByClient, "ScriptInfo needs to be opened by client to be able to set its user defined content");
     const path = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
-    let info = this.getScriptInfoForPath(path);
+    let info = this.filenameToScriptInfo.get(path);
     if (!info) {
       const isDynamic = isDynamicFileName(fileName);
       Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
@@ -183907,7 +184315,7 @@ Dynamic files must always be opened with service's current directory or service
       if (!openedByClient && !isDynamic && !(hostToQueryFileExistsOn || this.host).fileExists(fileName)) {
         return;
       }
-      info = new ScriptInfo(this.host, fileName, scriptKind, !!hasMixedContent, path, this.filenameToScriptInfoVersion.get(path));
+      info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent, path, this.filenameToScriptInfoVersion.get(path));
       this.filenameToScriptInfo.set(info.path, info);
       this.filenameToScriptInfoVersion.delete(info.path);
       if (!openedByClient) {
@@ -183915,6 +184323,12 @@ Dynamic files must always be opened with service's current directory or service
       } else if (!isRootedDiskPath(fileName) && (!isDynamic || this.currentDirectory !== currentDirectory)) {
         this.openFilesWithNonRootedDiskPath.set(this.toCanonicalFileName(fileName), info);
       }
+    } else if (info.deferredDelete) {
+      Debug.assert(!info.isDynamic);
+      if (!openedByClient && !(hostToQueryFileExistsOn || this.host).fileExists(fileName)) {
+        return deferredDeleteOk ? info : void 0;
+      }
+      info.deferredDelete = void 0;
     }
     if (openedByClient) {
       this.stopWatchingScriptInfo(info);
@@ -183932,11 +184346,18 @@ Dynamic files must always be opened with service's current directory or service
     return !isRootedDiskPath(fileName) && this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(fileName)) || this.getScriptInfoForPath(normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName));
   }
   getScriptInfoForPath(fileName) {
-    return this.filenameToScriptInfo.get(fileName);
+    const info = this.filenameToScriptInfo.get(fileName);
+    return !info || !info.deferredDelete ? info : void 0;
   }
   /** @internal */
   getDocumentPositionMapper(project, generatedFileName, sourceFileName) {
-    const declarationInfo = this.getOrCreateScriptInfoNotOpenedByClient(generatedFileName, project.currentDirectory, this.host);
+    const declarationInfo = this.getOrCreateScriptInfoNotOpenedByClient(
+      generatedFileName,
+      project.currentDirectory,
+      this.host,
+      /*deferredDeleteOk*/
+      false
+    );
     if (!declarationInfo) {
       if (sourceFileName) {
         project.addGeneratedFileWatch(generatedFileName, sourceFileName);
@@ -183961,14 +184382,17 @@ Dynamic files must always be opened with service's current directory or service
       return void 0;
     }
     let sourceMapFileInfo;
-    let mapFileNameFromDeclarationInfo;
     let readMapFile = (mapFileName, mapFileNameFromDts) => {
-      const mapInfo = this.getOrCreateScriptInfoNotOpenedByClient(mapFileName, project.currentDirectory, this.host);
-      if (!mapInfo) {
-        mapFileNameFromDeclarationInfo = mapFileNameFromDts;
+      const mapInfo = this.getOrCreateScriptInfoNotOpenedByClient(
+        mapFileName,
+        project.currentDirectory,
+        this.host,
+        /*deferredDeleteOk*/
+        true
+      );
+      sourceMapFileInfo = mapInfo || mapFileNameFromDts;
+      if (!mapInfo || mapInfo.deferredDelete)
         return void 0;
-      }
-      sourceMapFileInfo = mapInfo;
       const snap = mapInfo.getSnapshot();
       if (mapInfo.documentPositionMapper !== void 0)
         return mapInfo.documentPositionMapper;
@@ -183983,18 +184407,21 @@ Dynamic files must always be opened with service's current directory or service
     );
     readMapFile = void 0;
     if (sourceMapFileInfo) {
-      declarationInfo.sourceMapFilePath = sourceMapFileInfo.path;
-      sourceMapFileInfo.declarationInfoPath = declarationInfo.path;
-      sourceMapFileInfo.documentPositionMapper = documentPositionMapper || false;
-      sourceMapFileInfo.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, sourceMapFileInfo.sourceInfos);
-    } else if (mapFileNameFromDeclarationInfo) {
-      declarationInfo.sourceMapFilePath = {
-        watcher: this.addMissingSourceMapFile(
-          project.currentDirectory === this.currentDirectory ? mapFileNameFromDeclarationInfo : getNormalizedAbsolutePath(mapFileNameFromDeclarationInfo, project.currentDirectory),
-          declarationInfo.path
-        ),
-        sourceInfos: this.addSourceInfoToSourceMap(sourceFileName, project)
-      };
+      if (!isString(sourceMapFileInfo)) {
+        declarationInfo.sourceMapFilePath = sourceMapFileInfo.path;
+        sourceMapFileInfo.declarationInfoPath = declarationInfo.path;
+        if (!sourceMapFileInfo.deferredDelete)
+          sourceMapFileInfo.documentPositionMapper = documentPositionMapper || false;
+        sourceMapFileInfo.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, sourceMapFileInfo.sourceInfos);
+      } else {
+        declarationInfo.sourceMapFilePath = {
+          watcher: this.addMissingSourceMapFile(
+            project.currentDirectory === this.currentDirectory ? sourceMapFileInfo : getNormalizedAbsolutePath(sourceMapFileInfo, project.currentDirectory),
+            declarationInfo.path
+          ),
+          sourceInfos: this.addSourceInfoToSourceMap(sourceFileName, project)
+        };
+      }
     } else {
       declarationInfo.sourceMapFilePath = false;
     }
@@ -184002,7 +184429,13 @@ Dynamic files must always be opened with service's current directory or service
   }
   addSourceInfoToSourceMap(sourceFileName, project, sourceInfos) {
     if (sourceFileName) {
-      const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient(sourceFileName, project.currentDirectory, project.directoryStructureHost);
+      const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient(
+        sourceFileName,
+        project.currentDirectory,
+        project.directoryStructureHost,
+        /*deferredDeleteOk*/
+        false
+      );
       (sourceInfos || (sourceInfos = /* @__PURE__ */ new Set())).add(sourceInfo.path);
     }
     return sourceInfos;
@@ -184037,13 +184470,19 @@ Dynamic files must always be opened with service's current directory or service
       if (sourceFile && sourceFile.resolvedPath === path)
         return sourceFile;
     }
-    const info = this.getOrCreateScriptInfoNotOpenedByClient(fileName, (project || this).currentDirectory, project ? project.directoryStructureHost : this.host);
+    const info = this.getOrCreateScriptInfoNotOpenedByClient(
+      fileName,
+      (project || this).currentDirectory,
+      project ? project.directoryStructureHost : this.host,
+      /*deferredDeleteOk*/
+      false
+    );
     if (!info)
       return void 0;
     if (declarationInfo && isString(declarationInfo.sourceMapFilePath) && info !== declarationInfo) {
       const sourceMapInfo = this.getScriptInfoForPath(declarationInfo.sourceMapFilePath);
       if (sourceMapInfo) {
-        (sourceMapInfo.sourceInfos || (sourceMapInfo.sourceInfos = /* @__PURE__ */ new Set())).add(info.path);
+        (sourceMapInfo.sourceInfos ?? (sourceMapInfo.sourceInfos = /* @__PURE__ */ new Set())).add(info.path);
       }
     }
     if (info.cacheSourceFile)
@@ -184093,7 +184532,7 @@ Dynamic files must always be opened with service's current directory or service
         if (lazyConfiguredProjectsFromExternalProject && !this.hostConfiguration.preferences.lazyConfiguredProjectsFromExternalProject) {
           this.externalProjectToConfiguredProjectMap.forEach(
             (projects) => projects.forEach((project) => {
-              if (!project.isClosed() && project.hasExternalProjectRef() && project.pendingUpdateLevel === 2 /* Full */ && !this.pendingProjectUpdates.has(project.getProjectName())) {
+              if (!project.deferredClose && !project.isClosed() && project.hasExternalProjectRef() && project.pendingUpdateLevel === 2 /* Full */ && !this.pendingProjectUpdates.has(project.getProjectName())) {
                 project.updateGraph();
               }
             })
@@ -184138,7 +184577,10 @@ Dynamic files must always be opened with service's current directory or service
         return;
       if (!info.fileWatcher)
         return;
-      this.onSourceFileChanged(info, this.host.fileExists(info.fileName) ? 1 /* Changed */ : 2 /* Deleted */);
+      this.onSourceFileChanged(
+        info,
+        this.host.fileExists(info.fileName) ? info.deferredDelete ? 0 /* Created */ : 1 /* Changed */ : 2 /* Deleted */
+      );
     });
     this.pendingProjectUpdates.forEach((_project, projectName) => {
       this.throttledOperations.cancel(projectName);
@@ -184150,15 +184592,7 @@ Dynamic files must always be opened with service's current directory or service
       if (info.config)
         info.config.updateLevel = 2 /* Full */;
     });
-    this.reloadConfiguredProjectForFiles(
-      this.openFiles,
-      /*clearSemanticCache*/
-      true,
-      /*delayReload*/
-      false,
-      returnTrue,
-      "User requested reload projects"
-    );
+    this.reloadConfiguredProjectForFiles("User requested reload projects");
     this.externalProjects.forEach((project) => {
       this.clearSemanticCache(project);
       project.updateGraph();
@@ -184171,69 +184605,57 @@ Dynamic files must always be opened with service's current directory or service
   /**
    * This function goes through all the openFiles and tries to file the config file for them.
    * If the config file is found and it refers to existing project, it reloads it either immediately
-   * or schedules it for reload depending on delayReload option
    * If there is no existing project it just opens the configured project for the config file
-   * reloadForInfo provides a way to filter out files to reload configured project for
    */
-  reloadConfiguredProjectForFiles(openFiles, clearSemanticCache, delayReload, shouldReloadProjectFor, reason) {
-    const updatedProjects = /* @__PURE__ */ new Map();
+  reloadConfiguredProjectForFiles(reason) {
+    var _a;
+    const updatedProjects = /* @__PURE__ */ new Set();
     const reloadChildProject = (child) => {
-      if (!updatedProjects.has(child.canonicalConfigFilePath)) {
-        updatedProjects.set(child.canonicalConfigFilePath, true);
+      if (tryAddToSet(updatedProjects, child)) {
         this.reloadConfiguredProject(
           child,
           reason,
           /*isInitialLoad*/
           false,
-          clearSemanticCache
+          /*clearSemanticCache*/
+          true
         );
       }
     };
-    openFiles == null ? void 0 : openFiles.forEach((openFileValue, path) => {
+    (_a = this.openFiles) == null ? void 0 : _a.forEach((_projectRoot, path) => {
       this.configFileForOpenFiles.delete(path);
-      if (!shouldReloadProjectFor(openFileValue)) {
-        return;
-      }
       const info = this.getScriptInfoForPath(path);
       Debug.assert(info.isScriptOpen());
       const configFileName = this.getConfigFileNameForFile(info);
       if (configFileName) {
         const project = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProject(configFileName);
-        if (!updatedProjects.has(project.canonicalConfigFilePath)) {
-          updatedProjects.set(project.canonicalConfigFilePath, true);
-          if (delayReload) {
-            project.pendingUpdateLevel = 2 /* Full */;
-            project.pendingUpdateReason = reason;
-            if (clearSemanticCache)
-              this.clearSemanticCache(project);
-            this.delayUpdateProjectGraph(project);
-          } else {
-            this.reloadConfiguredProject(
+        if (tryAddToSet(updatedProjects, project)) {
+          this.reloadConfiguredProject(
+            project,
+            reason,
+            /*isInitialLoad*/
+            false,
+            /*clearSemanticCache*/
+            true
+          );
+          if (!projectContainsInfoDirectly(project, info)) {
+            const referencedProject = forEachResolvedProjectReferenceProject(
               project,
-              reason,
-              /*isInitialLoad*/
-              false,
-              clearSemanticCache
+              info.path,
+              (child) => {
+                reloadChildProject(child);
+                return projectContainsInfoDirectly(child, info);
+              },
+              1 /* FindCreate */
             );
-            if (!projectContainsInfoDirectly(project, info)) {
-              const referencedProject = forEachResolvedProjectReferenceProject(
+            if (referencedProject) {
+              forEachResolvedProjectReferenceProject(
                 project,
-                info.path,
-                (child) => {
-                  reloadChildProject(child);
-                  return projectContainsInfoDirectly(child, info);
-                },
-                1 /* FindCreate */
+                /*fileName*/
+                void 0,
+                reloadChildProject,
+                0 /* Find */
               );
-              if (referencedProject) {
-                forEachResolvedProjectReferenceProject(
-                  project,
-                  /*fileName*/
-                  void 0,
-                  reloadChildProject,
-                  0 /* Find */
-                );
-              }
             }
           }
         }
@@ -184350,10 +184772,7 @@ Dynamic files must always be opened with service's current directory or service
     });
     return originalLocation;
     function addOriginalConfiguredProject(originalProject) {
-      if (!project.originalConfiguredProjects) {
-        project.originalConfiguredProjects = /* @__PURE__ */ new Set();
-      }
-      project.originalConfiguredProjects.add(originalProject.canonicalConfigFilePath);
+      (project.originalConfiguredProjects ?? (project.originalConfiguredProjects = /* @__PURE__ */ new Set())).add(originalProject.canonicalConfigFilePath);
     }
   }
   /** @internal */
@@ -184367,7 +184786,19 @@ Dynamic files must always be opened with service's current directory or service
     });
   }
   getOrCreateOpenScriptInfo(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath) {
-    const info = this.getOrCreateScriptInfoOpenedByClientForNormalizedPath(fileName, projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory, fileContent, scriptKind, hasMixedContent);
+    const info = this.getOrCreateScriptInfoWorker(
+      fileName,
+      projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory,
+      /*openedByClient*/
+      true,
+      fileContent,
+      scriptKind,
+      !!hasMixedContent,
+      /*hostToQueryFileExistsOn*/
+      void 0,
+      /*deferredDeleteOk*/
+      true
+    );
     this.openFiles.set(info.path, projectRootPath);
     return info;
   }
@@ -184513,7 +184944,7 @@ Dynamic files must always be opened with service's current directory or service
   removeOrphanConfiguredProjects(toRetainConfiguredProjects) {
     const toRemoveConfiguredProjects = new Map(this.configuredProjects);
     const markOriginalProjectsAsUsed = (project) => {
-      if (!project.isOrphan() && project.originalConfiguredProjects) {
+      if (project.originalConfiguredProjects && (isConfiguredProject(project) || !project.isOrphan())) {
         project.originalConfiguredProjects.forEach(
           (_value, configuredProjectPath) => {
             const project2 = this.getConfiguredProjectByCanonicalConfigFilePath(configuredProjectPath);
@@ -184532,18 +184963,17 @@ Dynamic files must always be opened with service's current directory or service
     this.inferredProjects.forEach(markOriginalProjectsAsUsed);
     this.externalProjects.forEach(markOriginalProjectsAsUsed);
     this.configuredProjects.forEach((project) => {
+      if (!toRemoveConfiguredProjects.has(project.canonicalConfigFilePath))
+        return;
       if (project.hasOpenRef()) {
         retainConfiguredProject(project);
-      } else if (toRemoveConfiguredProjects.has(project.canonicalConfigFilePath)) {
-        forEachReferencedProject(
-          project,
-          (ref) => isRetained(ref) && retainConfiguredProject(project)
-        );
+      } else if (forEachReferencedProject(project, (ref) => isRetained(ref))) {
+        retainConfiguredProject(project);
       }
     });
     toRemoveConfiguredProjects.forEach((project) => this.removeProject(project));
     function isRetained(project) {
-      return project.hasOpenRef() || !toRemoveConfiguredProjects.has(project.canonicalConfigFilePath);
+      return !toRemoveConfiguredProjects.has(project.canonicalConfigFilePath) || project.hasOpenRef();
     }
     function retainConfiguredProject(project) {
       if (toRemoveConfiguredProjects.delete(project.canonicalConfigFilePath)) {
@@ -184555,13 +184985,15 @@ Dynamic files must always be opened with service's current directory or service
   removeOrphanScriptInfos() {
     const toRemoveScriptInfos = new Map(this.filenameToScriptInfo);
     this.filenameToScriptInfo.forEach((info) => {
+      if (info.deferredDelete)
+        return;
       if (!info.isScriptOpen() && info.isOrphan() && !info.isContainedByBackgroundProject()) {
         if (!info.sourceMapFilePath)
           return;
         let sourceInfos;
         if (isString(info.sourceMapFilePath)) {
-          const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
-          sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
+          const sourceMapInfo = this.filenameToScriptInfo.get(info.sourceMapFilePath);
+          sourceInfos = sourceMapInfo == null ? void 0 : sourceMapInfo.sourceInfos;
         } else {
           sourceInfos = info.sourceMapFilePath.sourceInfos;
         }
@@ -184578,9 +185010,16 @@ Dynamic files must always be opened with service's current directory or service
       if (info.sourceMapFilePath) {
         let sourceInfos;
         if (isString(info.sourceMapFilePath)) {
-          toRemoveScriptInfos.delete(info.sourceMapFilePath);
-          const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
-          sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
+          const sourceMapInfo = this.filenameToScriptInfo.get(info.sourceMapFilePath);
+          if (sourceMapInfo == null ? void 0 : sourceMapInfo.deferredDelete) {
+            info.sourceMapFilePath = {
+              watcher: this.addMissingSourceMapFile(sourceMapInfo.fileName, info.path),
+              sourceInfos: sourceMapInfo.sourceInfos
+            };
+          } else {
+            toRemoveScriptInfos.delete(info.sourceMapFilePath);
+          }
+          sourceInfos = sourceMapInfo == null ? void 0 : sourceMapInfo.sourceInfos;
         } else {
           sourceInfos = info.sourceMapFilePath.sourceInfos;
         }
@@ -184589,11 +185028,7 @@ Dynamic files must always be opened with service's current directory or service
         }
       }
     });
-    toRemoveScriptInfos.forEach((info) => {
-      this.stopWatchingScriptInfo(info);
-      this.deleteScriptInfo(info);
-      info.closeSourceMapFileWatcher();
-    });
+    toRemoveScriptInfos.forEach((info) => this.deleteScriptInfo(info));
   }
   telemetryOnOpenFile(scriptInfo) {
     if (this.serverMode !== 0 /* Semantic */ || !this.eventHandler || !scriptInfo.isJavaScript() || !addToSeen(this.allJsFilesForOpenFileTelemetry, scriptInfo.path)) {
@@ -184625,7 +185060,7 @@ Dynamic files must always be opened with service's current directory or service
   synchronizeProjectList(knownProjects, includeProjectReferenceRedirectInfo) {
     const files = [];
     this.collectChanges(knownProjects, this.externalProjects, includeProjectReferenceRedirectInfo, files);
-    this.collectChanges(knownProjects, this.configuredProjects.values(), includeProjectReferenceRedirectInfo, files);
+    this.collectChanges(knownProjects, mapDefinedIterator(this.configuredProjects.values(), (p) => p.deferredClose ? void 0 : p), includeProjectReferenceRedirectInfo, files);
     this.collectChanges(knownProjects, this.inferredProjects, includeProjectReferenceRedirectInfo, files);
     return files;
   }
@@ -184998,19 +185433,22 @@ Dynamic files must always be opened with service's current directory or service
   }
   async enableRequestedPluginsWorker(pendingPlugins) {
     Debug.assert(this.currentPluginEnablementPromise === void 0);
-    await Promise.all(map(pendingPlugins, ([project, promises]) => this.enableRequestedPluginsForProjectAsync(project, promises)));
+    let sendProjectsUpdatedInBackgroundEvent = false;
+    await Promise.all(map(pendingPlugins, async ([project, promises]) => {
+      const results = await Promise.all(promises);
+      if (project.isClosed() || isProjectDeferredClose(project)) {
+        this.logger.info(`Cancelling plugin enabling for ${project.getProjectName()} as it is ${project.isClosed() ? "closed" : "deferred close"}`);
+        return;
+      }
+      sendProjectsUpdatedInBackgroundEvent = true;
+      for (const result of results) {
+        this.endEnablePlugin(project, result);
+      }
+      this.delayUpdateProjectGraph(project);
+    }));
     this.currentPluginEnablementPromise = void 0;
-    this.sendProjectsUpdatedInBackgroundEvent();
-  }
-  async enableRequestedPluginsForProjectAsync(project, promises) {
-    const results = await Promise.all(promises);
-    if (project.isClosed()) {
-      return;
-    }
-    for (const result of results) {
-      this.endEnablePlugin(project, result);
-    }
-    this.delayUpdateProjectGraph(project);
+    if (sendProjectsUpdatedInBackgroundEvent)
+      this.sendProjectsUpdatedInBackgroundEvent();
   }
   configurePlugin(args) {
     this.forEachEnabledProject((project) => project.onPluginConfigurationChanged(args.pluginName, args.configuration));
@@ -187004,7 +187442,9 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(
             fileNameToSearch,
             noDtsProject.currentDirectory,
-            noDtsProject.directoryStructureHost
+            noDtsProject.directoryStructureHost,
+            /*deferredDeleteOk*/
+            false
           );
           if (!info)
             continue;
@@ -189626,6 +190066,7 @@ __export(ts_server_exports4, {
   isExternalProject: () => isExternalProject,
   isInferredProject: () => isInferredProject,
   isInferredProjectName: () => isInferredProjectName,
+  isProjectDeferredClose: () => isProjectDeferredClose,
   makeAutoImportProviderProjectName: () => makeAutoImportProviderProjectName,
   makeAuxiliaryProjectName: () => makeAuxiliaryProjectName,
   makeInferredProjectName: () => makeInferredProjectName,
@@ -189885,6 +190326,7 @@ if (typeof console !== "undefined") {
   canHaveJSDoc,
   canHaveLocals,
   canHaveModifiers,
+  canHaveModuleSpecifier,
   canHaveSymbol,
   canJsonReportNoInputFiles,
   canProduceDiagnostics,
@@ -190351,6 +190793,7 @@ if (typeof console !== "undefined") {
   getDefaultLibFileName,
   getDefaultLibFilePath,
   getDefaultLikeExportInfo,
+  getDefaultResolutionModeForFileWorker,
   getDiagnosticText,
   getDiagnosticsWithinSpan,
   getDirectoryPath,
@@ -190381,6 +190824,7 @@ if (typeof console !== "undefined") {
   getEmitFlags,
   getEmitHelpers,
   getEmitModuleDetectionKind,
+  getEmitModuleFormatOfFileWorker,
   getEmitModuleKind,
   getEmitModuleResolutionKind,
   getEmitScriptTarget,
@@ -190431,6 +190875,7 @@ if (typeof console !== "undefined") {
   getIdentifierGeneratedImportReference,
   getIdentifierTypeArguments,
   getImmediatelyInvokedFunctionExpression,
+  getImpliedNodeFormatForEmitWorker,
   getImpliedNodeFormatForFile,
   getImpliedNodeFormatForFileWorker,
   getImportNeedsImportDefaultHelper,
@@ -190786,6 +191231,7 @@ if (typeof console !== "undefined") {
   importDefaultHelper,
   importFromModuleSpecifier,
   importStarHelper,
+  importSyntaxAffectsModuleResolution,
   indexOfAnyCharCode,
   indexOfNode,
   indicesOf,
@@ -191875,11 +192321,11 @@ if (typeof console !== "undefined") {
   transformESDecorators,
   transformESNext,
   transformGenerators,
+  transformImpliedNodeFormatDependentModule,
   transformJsx,
   transformLegacyDecorators,
   transformModule,
   transformNamedEvaluation,
-  transformNodeModule,
   transformNodes,
   transformSystemModule,
   transformTypeScript,