typescript 5.5.0-dev.20240411 → 5.5.0-dev.20240413

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240411`;
+var version = `${versionMajorMinor}.0-dev.20240413`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4307,7 +4307,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) {
@@ -4317,10 +4317,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);
@@ -4331,11 +4333,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);
@@ -4343,19 +4349,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)) {
@@ -4383,6 +4395,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);
@@ -4390,7 +4410,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) {
@@ -4407,6 +4428,7 @@ function createDirectoryWatcherSupportingRecursive({
     timerToUpdateChildWatches = setTimeout2(onTimerToUpdateChildWatches, 1e3, "timerToUpdateChildWatches");
   }
   function onTimerToUpdateChildWatches() {
+    var _a;
     timerToUpdateChildWatches = void 0;
     sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
     const start = timestamp();
@@ -4417,7 +4439,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) => {
@@ -4445,22 +4468,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) {
@@ -5955,6 +6002,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."),
@@ -10060,6 +10108,8 @@ function getDefaultLibFileName(options) {
   switch (getEmitScriptTarget(options)) {
     case 99 /* ESNext */:
       return "lib.esnext.full.d.ts";
+    case 10 /* ES2023 */:
+      return "lib.es2023.full.d.ts";
     case 9 /* ES2022 */:
       return "lib.es2022.full.d.ts";
     case 8 /* ES2021 */:
@@ -12644,6 +12694,9 @@ function getErrorSpanForNode(sourceFile, node) {
   }
   return createTextSpanFromBounds(pos, errorNode.end);
 }
+function isGlobalSourceFile(node) {
+  return node.kind === 307 /* SourceFile */ && !isExternalOrCommonJsModule(node);
+}
 function isExternalOrCommonJsModule(file) {
   return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== void 0;
 }
@@ -13704,6 +13757,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) {
@@ -16378,8 +16448,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)) {
@@ -16398,10 +16468,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;
 }
@@ -17820,6 +17894,380 @@ function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameEx
   }
   return evaluate;
 }
+function isConstAssertion(location) {
+  return isAssertionExpression(location) && isConstTypeReference(location.type) || isJSDocTypeTag(location) && isConstTypeReference(location.typeExpression);
+}
+function findConstructorDeclaration(node) {
+  const members = node.members;
+  for (const member of members) {
+    if (member.kind === 176 /* Constructor */ && nodeIsPresent(member.body)) {
+      return member;
+    }
+  }
+}
+function createNameResolver({
+  compilerOptions,
+  requireSymbol,
+  argumentsSymbol,
+  error,
+  getSymbolOfDeclaration,
+  globals,
+  lookup,
+  setRequiresScopeChangeCache = returnUndefined,
+  getRequiresScopeChangeCache = returnUndefined,
+  onPropertyWithInvalidInitializer = returnFalse,
+  onFailedToResolveSymbol = returnUndefined,
+  onSuccessfullyResolvedSymbol = returnUndefined
+}) {
+  var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
+  var emitStandardClassFields = getEmitStandardClassFields(compilerOptions);
+  var emptySymbols = createSymbolTable();
+  return resolveNameHelper;
+  function resolveNameHelper(location, nameArg, meaning, nameNotFoundMessage, isUse, excludeGlobals) {
+    var _a, _b, _c;
+    const originalLocation = location;
+    let result;
+    let lastLocation;
+    let lastSelfReferenceLocation;
+    let propertyWithInvalidInitializer;
+    let associatedDeclarationForContainingInitializerOrBindingName;
+    let withinDeferredContext = false;
+    let grandparent;
+    const name = isString(nameArg) ? nameArg : nameArg.escapedText;
+    loop:
+      while (location) {
+        if (name === "const" && isConstAssertion(location)) {
+          return void 0;
+        }
+        if (isModuleOrEnumDeclaration(location) && lastLocation && location.name === lastLocation) {
+          lastLocation = location;
+          location = location.parent;
+        }
+        if (canHaveLocals(location) && location.locals && !isGlobalSourceFile(location)) {
+          if (result = lookup(location.locals, name, meaning)) {
+            let useResult = true;
+            if (isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
+              if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 320 /* JSDoc */) {
+                useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
+              }
+              if (meaning & result.flags & 3 /* Variable */) {
+                if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
+                  useResult = false;
+                } else if (result.flags & 1 /* FunctionScopedVariable */) {
+                  useResult = lastLocation.kind === 169 /* Parameter */ || lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
+                }
+              }
+            } else if (location.kind === 194 /* ConditionalType */) {
+              useResult = lastLocation === location.trueType;
+            }
+            if (useResult) {
+              break loop;
+            } else {
+              result = void 0;
+            }
+          }
+        }
+        withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation);
+        switch (location.kind) {
+          case 307 /* SourceFile */:
+            if (!isExternalOrCommonJsModule(location))
+              break;
+          case 267 /* ModuleDeclaration */:
+            const moduleExports = ((_a = getSymbolOfDeclaration(location)) == null ? void 0 : _a.exports) || emptySymbols;
+            if (location.kind === 307 /* SourceFile */ || isModuleDeclaration(location) && location.flags & 33554432 /* Ambient */ && !isGlobalScopeAugmentation(location)) {
+              if (result = moduleExports.get("default" /* Default */)) {
+                const localSymbol = getLocalSymbolForExportDefault(result);
+                if (localSymbol && result.flags & meaning && localSymbol.escapedName === name) {
+                  break loop;
+                }
+                result = void 0;
+              }
+              const moduleExport = moduleExports.get(name);
+              if (moduleExport && moduleExport.flags === 2097152 /* Alias */ && (getDeclarationOfKind(moduleExport, 281 /* ExportSpecifier */) || getDeclarationOfKind(moduleExport, 280 /* NamespaceExport */))) {
+                break;
+              }
+            }
+            if (name !== "default" /* Default */ && (result = lookup(moduleExports, name, meaning & 2623475 /* ModuleMember */))) {
+              if (isSourceFile(location) && location.commonJsModuleIndicator && !((_b = result.declarations) == null ? void 0 : _b.some(isJSDocTypeAlias))) {
+                result = void 0;
+              } else {
+                break loop;
+              }
+            }
+            break;
+          case 266 /* EnumDeclaration */:
+            if (result = lookup(((_c = getSymbolOfDeclaration(location)) == null ? void 0 : _c.exports) || emptySymbols, name, meaning & 8 /* EnumMember */)) {
+              if (nameNotFoundMessage && getIsolatedModules(compilerOptions) && !(location.flags & 33554432 /* Ambient */) && getSourceFileOfNode(location) !== getSourceFileOfNode(result.valueDeclaration)) {
+                error(
+                  originalLocation,
+                  Diagnostics.Cannot_access_0_from_another_file_without_qualification_when_1_is_enabled_Use_2_instead,
+                  unescapeLeadingUnderscores(name),
+                  isolatedModulesLikeFlagName,
+                  `${unescapeLeadingUnderscores(getSymbolOfDeclaration(location).escapedName)}.${unescapeLeadingUnderscores(name)}`
+                );
+              }
+              break loop;
+            }
+            break;
+          case 172 /* PropertyDeclaration */:
+            if (!isStatic(location)) {
+              const ctor = findConstructorDeclaration(location.parent);
+              if (ctor && ctor.locals) {
+                if (lookup(ctor.locals, name, meaning & 111551 /* Value */)) {
+                  Debug.assertNode(location, isPropertyDeclaration);
+                  propertyWithInvalidInitializer = location;
+                }
+              }
+            }
+            break;
+          case 263 /* ClassDeclaration */:
+          case 231 /* ClassExpression */:
+          case 264 /* InterfaceDeclaration */:
+            if (result = lookup(getSymbolOfDeclaration(location).members || emptySymbols, name, meaning & 788968 /* Type */)) {
+              if (!isTypeParameterSymbolDeclaredInContainer(result, location)) {
+                result = void 0;
+                break;
+              }
+              if (lastLocation && isStatic(lastLocation)) {
+                if (nameNotFoundMessage) {
+                  error(originalLocation, Diagnostics.Static_members_cannot_reference_class_type_parameters);
+                }
+                return void 0;
+              }
+              break loop;
+            }
+            if (isClassExpression(location) && meaning & 32 /* Class */) {
+              const className = location.name;
+              if (className && name === className.escapedText) {
+                result = location.symbol;
+                break loop;
+              }
+            }
+            break;
+          case 233 /* ExpressionWithTypeArguments */:
+            if (lastLocation === location.expression && location.parent.token === 96 /* ExtendsKeyword */) {
+              const container = location.parent.parent;
+              if (isClassLike(container) && (result = lookup(getSymbolOfDeclaration(container).members, name, meaning & 788968 /* Type */))) {
+                if (nameNotFoundMessage) {
+                  error(originalLocation, Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
+                }
+                return void 0;
+              }
+            }
+            break;
+          case 167 /* ComputedPropertyName */:
+            grandparent = location.parent.parent;
+            if (isClassLike(grandparent) || grandparent.kind === 264 /* InterfaceDeclaration */) {
+              if (result = lookup(getSymbolOfDeclaration(grandparent).members, name, meaning & 788968 /* Type */)) {
+                if (nameNotFoundMessage) {
+                  error(originalLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
+                }
+                return void 0;
+              }
+            }
+            break;
+          case 219 /* ArrowFunction */:
+            if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
+              break;
+            }
+          case 174 /* MethodDeclaration */:
+          case 176 /* Constructor */:
+          case 177 /* GetAccessor */:
+          case 178 /* SetAccessor */:
+          case 262 /* FunctionDeclaration */:
+            if (meaning & 3 /* Variable */ && name === "arguments") {
+              result = argumentsSymbol;
+              break loop;
+            }
+            break;
+          case 218 /* FunctionExpression */:
+            if (meaning & 3 /* Variable */ && name === "arguments") {
+              result = argumentsSymbol;
+              break loop;
+            }
+            if (meaning & 16 /* Function */) {
+              const functionName = location.name;
+              if (functionName && name === functionName.escapedText) {
+                result = location.symbol;
+                break loop;
+              }
+            }
+            break;
+          case 170 /* Decorator */:
+            if (location.parent && location.parent.kind === 169 /* Parameter */) {
+              location = location.parent;
+            }
+            if (location.parent && (isClassElement(location.parent) || location.parent.kind === 263 /* ClassDeclaration */)) {
+              location = location.parent;
+            }
+            break;
+          case 346 /* JSDocTypedefTag */:
+          case 338 /* JSDocCallbackTag */:
+          case 340 /* JSDocEnumTag */:
+          case 351 /* JSDocImportTag */:
+            const root = getJSDocRoot(location);
+            if (root) {
+              location = root.parent;
+            }
+            break;
+          case 169 /* Parameter */:
+            if (lastLocation && (lastLocation === location.initializer || lastLocation === location.name && isBindingPattern(lastLocation))) {
+              if (!associatedDeclarationForContainingInitializerOrBindingName) {
+                associatedDeclarationForContainingInitializerOrBindingName = location;
+              }
+            }
+            break;
+          case 208 /* BindingElement */:
+            if (lastLocation && (lastLocation === location.initializer || lastLocation === location.name && isBindingPattern(lastLocation))) {
+              if (isParameterDeclaration(location) && !associatedDeclarationForContainingInitializerOrBindingName) {
+                associatedDeclarationForContainingInitializerOrBindingName = location;
+              }
+            }
+            break;
+          case 195 /* InferType */:
+            if (meaning & 262144 /* TypeParameter */) {
+              const parameterName = location.typeParameter.name;
+              if (parameterName && name === parameterName.escapedText) {
+                result = location.typeParameter.symbol;
+                break loop;
+              }
+            }
+            break;
+          case 281 /* ExportSpecifier */:
+            if (lastLocation && lastLocation === location.propertyName && location.parent.parent.moduleSpecifier) {
+              location = location.parent.parent.parent;
+            }
+            break;
+        }
+        if (isSelfReferenceLocation(location)) {
+          lastSelfReferenceLocation = location;
+        }
+        lastLocation = location;
+        location = isJSDocTemplateTag(location) ? getEffectiveContainerForJSDocTemplateTag(location) || location.parent : isJSDocParameterTag(location) || isJSDocReturnTag(location) ? getHostSignatureFromJSDoc(location) || location.parent : location.parent;
+      }
+    if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
+      result.isReferenced |= meaning;
+    }
+    if (!result) {
+      if (lastLocation) {
+        Debug.assertNode(lastLocation, isSourceFile);
+        if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) {
+          return lastLocation.symbol;
+        }
+      }
+      if (!excludeGlobals) {
+        result = lookup(globals, name, meaning);
+      }
+    }
+    if (!result) {
+      if (originalLocation && isInJSFile(originalLocation) && originalLocation.parent) {
+        if (isRequireCall(
+          originalLocation.parent,
+          /*requireStringLiteralLikeArgument*/
+          false
+        )) {
+          return requireSymbol;
+        }
+      }
+    }
+    if (nameNotFoundMessage) {
+      if (propertyWithInvalidInitializer && onPropertyWithInvalidInitializer(originalLocation, name, propertyWithInvalidInitializer, result)) {
+        return void 0;
+      }
+      if (!result) {
+        onFailedToResolveSymbol(originalLocation, nameArg, meaning, nameNotFoundMessage);
+      } else {
+        onSuccessfullyResolvedSymbol(originalLocation, result, meaning, lastLocation, associatedDeclarationForContainingInitializerOrBindingName, withinDeferredContext);
+      }
+    }
+    return result;
+  }
+  function useOuterVariableScopeInParameter(result, location, lastLocation) {
+    const target = getEmitScriptTarget(compilerOptions);
+    const functionLocation = location;
+    if (isParameter(lastLocation) && functionLocation.body && result.valueDeclaration && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
+      if (target >= 2 /* ES2015 */) {
+        let declarationRequiresScopeChange = getRequiresScopeChangeCache(functionLocation);
+        if (declarationRequiresScopeChange === void 0) {
+          declarationRequiresScopeChange = forEach(functionLocation.parameters, requiresScopeChange) || false;
+          setRequiresScopeChangeCache(functionLocation, declarationRequiresScopeChange);
+        }
+        return !declarationRequiresScopeChange;
+      }
+    }
+    return false;
+    function requiresScopeChange(node) {
+      return requiresScopeChangeWorker(node.name) || !!node.initializer && requiresScopeChangeWorker(node.initializer);
+    }
+    function requiresScopeChangeWorker(node) {
+      switch (node.kind) {
+        case 219 /* ArrowFunction */:
+        case 218 /* FunctionExpression */:
+        case 262 /* FunctionDeclaration */:
+        case 176 /* Constructor */:
+          return false;
+        case 174 /* MethodDeclaration */:
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+        case 303 /* PropertyAssignment */:
+          return requiresScopeChangeWorker(node.name);
+        case 172 /* PropertyDeclaration */:
+          if (hasStaticModifier(node)) {
+            return !emitStandardClassFields;
+          }
+          return requiresScopeChangeWorker(node.name);
+        default:
+          if (isNullishCoalesce(node) || isOptionalChain(node)) {
+            return target < 7 /* ES2020 */;
+          }
+          if (isBindingElement(node) && node.dotDotDotToken && isObjectBindingPattern(node.parent)) {
+            return target < 4 /* ES2017 */;
+          }
+          if (isTypeNode(node))
+            return false;
+          return forEachChild(node, requiresScopeChangeWorker) || false;
+      }
+    }
+  }
+  function getIsDeferredContext(location, lastLocation) {
+    if (location.kind !== 219 /* ArrowFunction */ && location.kind !== 218 /* FunctionExpression */) {
+      return isTypeQueryNode(location) || (isFunctionLikeDeclaration(location) || location.kind === 172 /* PropertyDeclaration */ && !isStatic(location)) && (!lastLocation || lastLocation !== location.name);
+    }
+    if (lastLocation && lastLocation === location.name) {
+      return false;
+    }
+    if (location.asteriskToken || hasSyntacticModifier(location, 1024 /* Async */)) {
+      return true;
+    }
+    return !getImmediatelyInvokedFunctionExpression(location);
+  }
+  function isSelfReferenceLocation(node) {
+    switch (node.kind) {
+      case 262 /* FunctionDeclaration */:
+      case 263 /* ClassDeclaration */:
+      case 264 /* InterfaceDeclaration */:
+      case 266 /* EnumDeclaration */:
+      case 265 /* TypeAliasDeclaration */:
+      case 267 /* ModuleDeclaration */:
+        return true;
+      default:
+        return false;
+    }
+  }
+  function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
+    if (symbol.declarations) {
+      for (const decl of symbol.declarations) {
+        if (decl.kind === 168 /* TypeParameter */) {
+          const parent = isJSDocTemplateTag(decl.parent) ? getJSDocHost(decl.parent) : decl.parent;
+          if (parent === container) {
+            return !(isJSDocTemplateTag(decl.parent) && find(decl.parent.parent.tags, isJSDocTypeAlias));
+          }
+        }
+      }
+    }
+    return false;
+  }
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -25171,7 +25619,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 = [];
@@ -25236,8 +25684,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) {
@@ -34253,6 +34700,7 @@ var targetOptionDeclaration = {
     es2020: 7 /* ES2020 */,
     es2021: 8 /* ES2021 */,
     es2022: 9 /* ES2022 */,
+    es2023: 10 /* ES2023 */,
     esnext: 99 /* ESNext */
   })),
   affectsSourceFile: true,
@@ -42631,13 +43079,15 @@ function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignatu
 }
 
 // src/compiler/moduleSpecifiers.ts
-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 */];
         }
@@ -42670,7 +43120,7 @@ function getModuleSpecifierPreferences({ importModuleSpecifierPreference, import
     }
     return getModuleSpecifierEndingPreference(
       importModuleSpecifierEnding,
-      resolutionMode ?? importingSourceFile.impliedNodeFormat,
+      resolutionMode ?? getDefaultResolutionModeForFile(importingSourceFile, host, compilerOptions),
       compilerOptions,
       isFullSourceFile(importingSourceFile) ? importingSourceFile : void 0
     );
@@ -42731,14 +43181,17 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
 }
 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;
     }
@@ -43233,7 +43686,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;
@@ -43284,7 +43737,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);
@@ -43436,6 +43889,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 = /^".+"$/;
@@ -43646,6 +44102,31 @@ function createTypeChecker(host) {
   var lastGetCombinedNodeFlagsResult = 0 /* None */;
   var lastGetCombinedModifierFlagsNode;
   var lastGetCombinedModifierFlagsResult = 0 /* None */;
+  var resolveName = createNameResolver({
+    compilerOptions,
+    requireSymbol,
+    argumentsSymbol,
+    globals,
+    getSymbolOfDeclaration,
+    error,
+    getRequiresScopeChangeCache,
+    setRequiresScopeChangeCache,
+    lookup: getSymbol,
+    onPropertyWithInvalidInitializer: checkAndReportErrorForInvalidInitializer,
+    onFailedToResolveSymbol,
+    onSuccessfullyResolvedSymbol
+  });
+  var resolveNameForSymbolSuggestion = createNameResolver({
+    compilerOptions,
+    requireSymbol,
+    argumentsSymbol,
+    globals,
+    getSymbolOfDeclaration,
+    error,
+    getRequiresScopeChangeCache,
+    setRequiresScopeChangeCache,
+    lookup: getSuggestionForSymbolNameLookup
+  });
   const checker = {
     getNodeCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.nodeCount, 0),
     getIdentifierCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.identifierCount, 0),
@@ -43951,8 +44432,6 @@ function createTypeChecker(host) {
         meaning,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false,
         excludeGlobals
@@ -44982,9 +45461,6 @@ function createTypeChecker(host) {
     const nodeId = getNodeId(node);
     return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
   }
-  function isGlobalSourceFile(node) {
-    return node.kind === 307 /* SourceFile */ && !isExternalOrCommonJsModule(node);
-  }
   function getSymbol(symbols, name, meaning) {
     if (meaning) {
       const symbol = getMergedSymbol(symbols.get(name));
@@ -45160,417 +45636,120 @@ function createTypeChecker(host) {
       return ancestorChangingReferenceScope === void 0;
     }
   }
-  function useOuterVariableScopeInParameter(result, location, lastLocation) {
-    const target = getEmitScriptTarget(compilerOptions);
-    const functionLocation = location;
-    if (isParameter(lastLocation) && functionLocation.body && result.valueDeclaration && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
-      if (target >= 2 /* ES2015 */) {
-        const links = getNodeLinks(functionLocation);
-        if (links.declarationRequiresScopeChange === void 0) {
-          links.declarationRequiresScopeChange = forEach(functionLocation.parameters, requiresScopeChange) || false;
-        }
-        return !links.declarationRequiresScopeChange;
+  function getRequiresScopeChangeCache(node) {
+    return getNodeLinks(node).declarationRequiresScopeChange;
+  }
+  function setRequiresScopeChangeCache(node, value) {
+    getNodeLinks(node).declarationRequiresScopeChange = value;
+  }
+  function checkAndReportErrorForInvalidInitializer(errorLocation, name, propertyWithInvalidInitializer, result) {
+    if (!emitStandardClassFields) {
+      if (errorLocation && !result && checkAndReportErrorForMissingPrefix(errorLocation, name, name)) {
+        return true;
       }
+      error(
+        errorLocation,
+        errorLocation && propertyWithInvalidInitializer.type && textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos) ? Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor : Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor,
+        declarationNameToString(propertyWithInvalidInitializer.name),
+        diagnosticName(name)
+      );
+      return true;
     }
     return false;
-    function requiresScopeChange(node) {
-      return requiresScopeChangeWorker(node.name) || !!node.initializer && requiresScopeChangeWorker(node.initializer);
-    }
-    function requiresScopeChangeWorker(node) {
-      switch (node.kind) {
-        case 219 /* ArrowFunction */:
-        case 218 /* FunctionExpression */:
-        case 262 /* FunctionDeclaration */:
-        case 176 /* Constructor */:
-          return false;
-        case 174 /* MethodDeclaration */:
-        case 177 /* GetAccessor */:
-        case 178 /* SetAccessor */:
-        case 303 /* PropertyAssignment */:
-          return requiresScopeChangeWorker(node.name);
-        case 172 /* PropertyDeclaration */:
-          if (hasStaticModifier(node)) {
-            return !emitStandardClassFields;
-          }
-          return requiresScopeChangeWorker(node.name);
-        default:
-          if (isNullishCoalesce(node) || isOptionalChain(node)) {
-            return target < 7 /* ES2020 */;
-          }
-          if (isBindingElement(node) && node.dotDotDotToken && isObjectBindingPattern(node.parent)) {
-            return target < 4 /* ES2017 */;
-          }
-          if (isTypeNode(node))
-            return false;
-          return forEachChild(node, requiresScopeChangeWorker) || false;
-      }
-    }
-  }
-  function isConstAssertion(location) {
-    return isAssertionExpression(location) && isConstTypeReference(location.type) || isJSDocTypeTag(location) && isConstTypeReference(location.typeExpression);
   }
-  function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals = false, getSpellingSuggestions = true) {
-    return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, getSymbol);
-  }
-  function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, lookup) {
-    var _a, _b, _c;
-    const originalLocation = location;
-    let result;
-    let lastLocation;
-    let lastSelfReferenceLocation;
-    let propertyWithInvalidInitializer;
-    let associatedDeclarationForContainingInitializerOrBindingName;
-    let withinDeferredContext = false;
-    const errorLocation = location;
-    let grandparent;
-    let isInExternalModule = false;
-    loop:
-      while (location) {
-        if (name === "const" && isConstAssertion(location)) {
-          return void 0;
-        }
-        if (isModuleOrEnumDeclaration(location) && lastLocation && location.name === lastLocation) {
-          lastLocation = location;
-          location = location.parent;
-        }
-        if (canHaveLocals(location) && location.locals && !isGlobalSourceFile(location)) {
-          if (result = lookup(location.locals, name, meaning)) {
-            let useResult = true;
-            if (isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
-              if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 320 /* JSDoc */) {
-                useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
-              }
-              if (meaning & result.flags & 3 /* Variable */) {
-                if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
-                  useResult = false;
-                } else if (result.flags & 1 /* FunctionScopedVariable */) {
-                  useResult = lastLocation.kind === 169 /* Parameter */ || lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
-                }
-              }
-            } else if (location.kind === 194 /* ConditionalType */) {
-              useResult = lastLocation === location.trueType;
-            }
-            if (useResult) {
-              break loop;
-            } else {
-              result = void 0;
+  function onFailedToResolveSymbol(errorLocation, nameArg, meaning, nameNotFoundMessage) {
+    const name = isString(nameArg) ? nameArg : nameArg.escapedText;
+    addLazyDiagnostic(() => {
+      if (!errorLocation || errorLocation.parent.kind !== 324 /* JSDocLink */ && !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && !checkAndReportErrorForExtendingInterface(errorLocation) && !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) && !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
+        let suggestion;
+        let suggestedLib;
+        if (nameArg) {
+          suggestedLib = getSuggestedLibForNonExistentName(nameArg);
+          if (suggestedLib) {
+            error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib);
+          }
+        }
+        if (!suggestedLib && suggestionCount < maximumSuggestionCount) {
+          suggestion = getSuggestedSymbolForNonexistentSymbol(errorLocation, name, meaning);
+          const isGlobalScopeAugmentationDeclaration = (suggestion == null ? void 0 : suggestion.valueDeclaration) && isAmbientModule(suggestion.valueDeclaration) && isGlobalScopeAugmentation(suggestion.valueDeclaration);
+          if (isGlobalScopeAugmentationDeclaration) {
+            suggestion = void 0;
+          }
+          if (suggestion) {
+            const suggestionName = symbolToString(suggestion);
+            const isUncheckedJS = isUncheckedJSSuggestion(
+              errorLocation,
+              suggestion,
+              /*excludeClasses*/
+              false
+            );
+            const message = meaning === 1920 /* Namespace */ || nameArg && typeof nameArg !== "string" && nodeIsSynthesized(nameArg) ? Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 : isUncheckedJS ? Diagnostics.Could_not_find_name_0_Did_you_mean_1 : Diagnostics.Cannot_find_name_0_Did_you_mean_1;
+            const diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName);
+            addErrorOrSuggestion(!isUncheckedJS, diagnostic);
+            if (suggestion.valueDeclaration) {
+              addRelatedInfo(
+                diagnostic,
+                createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName)
+              );
             }
           }
         }
-        withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation);
-        switch (location.kind) {
-          case 307 /* SourceFile */:
-            if (!isExternalOrCommonJsModule(location))
-              break;
-            isInExternalModule = true;
-          case 267 /* ModuleDeclaration */:
-            const moduleExports = ((_a = getSymbolOfDeclaration(location)) == null ? void 0 : _a.exports) || emptySymbols;
-            if (location.kind === 307 /* SourceFile */ || isModuleDeclaration(location) && location.flags & 33554432 /* Ambient */ && !isGlobalScopeAugmentation(location)) {
-              if (result = moduleExports.get("default" /* Default */)) {
-                const localSymbol = getLocalSymbolForExportDefault(result);
-                if (localSymbol && result.flags & meaning && localSymbol.escapedName === name) {
-                  break loop;
-                }
-                result = void 0;
-              }
-              const moduleExport = moduleExports.get(name);
-              if (moduleExport && moduleExport.flags === 2097152 /* Alias */ && (getDeclarationOfKind(moduleExport, 281 /* ExportSpecifier */) || getDeclarationOfKind(moduleExport, 280 /* NamespaceExport */))) {
-                break;
-              }
-            }
-            if (name !== "default" /* Default */ && (result = lookup(moduleExports, name, meaning & 2623475 /* ModuleMember */))) {
-              if (isSourceFile(location) && location.commonJsModuleIndicator && !((_b = result.declarations) == null ? void 0 : _b.some(isJSDocTypeAlias))) {
-                result = void 0;
-              } else {
-                break loop;
-              }
-            }
-            break;
-          case 266 /* EnumDeclaration */:
-            if (result = lookup(((_c = getSymbolOfDeclaration(location)) == null ? void 0 : _c.exports) || emptySymbols, name, meaning & 8 /* EnumMember */)) {
-              if (nameNotFoundMessage && getIsolatedModules(compilerOptions) && !(location.flags & 33554432 /* Ambient */) && getSourceFileOfNode(location) !== getSourceFileOfNode(result.valueDeclaration)) {
-                error(
-                  errorLocation,
-                  Diagnostics.Cannot_access_0_from_another_file_without_qualification_when_1_is_enabled_Use_2_instead,
-                  unescapeLeadingUnderscores(name),
-                  isolatedModulesLikeFlagName,
-                  `${unescapeLeadingUnderscores(getSymbolOfNode(location).escapedName)}.${unescapeLeadingUnderscores(name)}`
-                );
-              }
-              break loop;
-            }
-            break;
-          case 172 /* PropertyDeclaration */:
-            if (!isStatic(location)) {
-              const ctor = findConstructorDeclaration(location.parent);
-              if (ctor && ctor.locals) {
-                if (lookup(ctor.locals, name, meaning & 111551 /* Value */)) {
-                  Debug.assertNode(location, isPropertyDeclaration);
-                  propertyWithInvalidInitializer = location;
-                }
-              }
-            }
-            break;
-          case 263 /* ClassDeclaration */:
-          case 231 /* ClassExpression */:
-          case 264 /* InterfaceDeclaration */:
-            if (result = lookup(getSymbolOfDeclaration(location).members || emptySymbols, name, meaning & 788968 /* Type */)) {
-              if (!isTypeParameterSymbolDeclaredInContainer(result, location)) {
-                result = void 0;
-                break;
-              }
-              if (lastLocation && isStatic(lastLocation)) {
-                if (nameNotFoundMessage) {
-                  error(errorLocation, Diagnostics.Static_members_cannot_reference_class_type_parameters);
-                }
-                return void 0;
-              }
-              break loop;
-            }
-            if (isClassExpression(location) && meaning & 32 /* Class */) {
-              const className = location.name;
-              if (className && name === className.escapedText) {
-                result = location.symbol;
-                break loop;
-              }
-            }
-            break;
-          case 233 /* ExpressionWithTypeArguments */:
-            if (lastLocation === location.expression && location.parent.token === 96 /* ExtendsKeyword */) {
-              const container = location.parent.parent;
-              if (isClassLike(container) && (result = lookup(getSymbolOfDeclaration(container).members, name, meaning & 788968 /* Type */))) {
-                if (nameNotFoundMessage) {
-                  error(errorLocation, Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
-                }
-                return void 0;
-              }
-            }
-            break;
-          case 167 /* ComputedPropertyName */:
-            grandparent = location.parent.parent;
-            if (isClassLike(grandparent) || grandparent.kind === 264 /* InterfaceDeclaration */) {
-              if (result = lookup(getSymbolOfDeclaration(grandparent).members, name, meaning & 788968 /* Type */)) {
-                if (nameNotFoundMessage) {
-                  error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
-                }
-                return void 0;
-              }
-            }
-            break;
-          case 219 /* ArrowFunction */:
-            if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
-              break;
-            }
-          case 174 /* MethodDeclaration */:
-          case 176 /* Constructor */:
-          case 177 /* GetAccessor */:
-          case 178 /* SetAccessor */:
-          case 262 /* FunctionDeclaration */:
-            if (meaning & 3 /* Variable */ && name === "arguments") {
-              result = argumentsSymbol;
-              break loop;
-            }
-            break;
-          case 218 /* FunctionExpression */:
-            if (meaning & 3 /* Variable */ && name === "arguments") {
-              result = argumentsSymbol;
-              break loop;
-            }
-            if (meaning & 16 /* Function */) {
-              const functionName = location.name;
-              if (functionName && name === functionName.escapedText) {
-                result = location.symbol;
-                break loop;
-              }
-            }
-            break;
-          case 170 /* Decorator */:
-            if (location.parent && location.parent.kind === 169 /* Parameter */) {
-              location = location.parent;
-            }
-            if (location.parent && (isClassElement(location.parent) || location.parent.kind === 263 /* ClassDeclaration */)) {
-              location = location.parent;
-            }
-            break;
-          case 346 /* JSDocTypedefTag */:
-          case 338 /* JSDocCallbackTag */:
-          case 340 /* JSDocEnumTag */:
-          case 351 /* JSDocImportTag */:
-            const root = getJSDocRoot(location);
-            if (root) {
-              location = root.parent;
-            }
-            break;
-          case 169 /* Parameter */:
-            if (lastLocation && (lastLocation === location.initializer || lastLocation === location.name && isBindingPattern(lastLocation))) {
-              if (!associatedDeclarationForContainingInitializerOrBindingName) {
-                associatedDeclarationForContainingInitializerOrBindingName = location;
-              }
-            }
-            break;
-          case 208 /* BindingElement */:
-            if (lastLocation && (lastLocation === location.initializer || lastLocation === location.name && isBindingPattern(lastLocation))) {
-              if (isParameterDeclaration(location) && !associatedDeclarationForContainingInitializerOrBindingName) {
-                associatedDeclarationForContainingInitializerOrBindingName = location;
-              }
-            }
-            break;
-          case 195 /* InferType */:
-            if (meaning & 262144 /* TypeParameter */) {
-              const parameterName = location.typeParameter.name;
-              if (parameterName && name === parameterName.escapedText) {
-                result = location.typeParameter.symbol;
-                break loop;
-              }
-            }
-            break;
-          case 281 /* ExportSpecifier */:
-            if (lastLocation && lastLocation === location.propertyName && location.parent.parent.moduleSpecifier) {
-              location = location.parent.parent.parent;
-            }
-            break;
+        if (!suggestion && !suggestedLib && nameArg) {
+          error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
         }
-        if (isSelfReferenceLocation(location)) {
-          lastSelfReferenceLocation = location;
-        }
-        lastLocation = location;
-        location = isJSDocTemplateTag(location) ? getEffectiveContainerForJSDocTemplateTag(location) || location.parent : isJSDocParameterTag(location) || isJSDocReturnTag(location) ? getHostSignatureFromJSDoc(location) || location.parent : location.parent;
-      }
-    if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
-      result.isReferenced |= meaning;
-    }
-    if (!result) {
-      if (lastLocation) {
-        Debug.assertNode(lastLocation, isSourceFile);
-        if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) {
-          return lastLocation.symbol;
-        }
-      }
-      if (!excludeGlobals) {
-        result = lookup(globals, name, meaning);
+        suggestionCount++;
       }
-    }
-    if (!result) {
-      if (originalLocation && isInJSFile(originalLocation) && originalLocation.parent) {
-        if (isRequireCall(
-          originalLocation.parent,
-          /*requireStringLiteralLikeArgument*/
-          false
-        )) {
-          return requireSymbol;
+    });
+  }
+  function onSuccessfullyResolvedSymbol(errorLocation, result, meaning, lastLocation, associatedDeclarationForContainingInitializerOrBindingName, withinDeferredContext) {
+    addLazyDiagnostic(() => {
+      var _a;
+      const name = result.escapedName;
+      const isInExternalModule = lastLocation && isSourceFile(lastLocation) && isExternalOrCommonJsModule(lastLocation);
+      if (errorLocation && (meaning & 2 /* BlockScopedVariable */ || (meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */)) {
+        const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
+        if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
+          checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
+        }
+      }
+      if (isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(errorLocation.flags & 16777216 /* JSDoc */)) {
+        const merged = getMergedSymbol(result);
+        if (length(merged.declarations) && every(merged.declarations, (d) => isNamespaceExportDeclaration(d) || isSourceFile(d) && !!d.symbol.globalExports)) {
+          errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name));
+        }
+      }
+      if (associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* Value */) === 111551 /* Value */) {
+        const candidate = getMergedSymbol(getLateBoundSymbol(result));
+        const root = getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
+        if (candidate === getSymbolOfDeclaration(associatedDeclarationForContainingInitializerOrBindingName)) {
+          error(errorLocation, Diagnostics.Parameter_0_cannot_reference_itself, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
+        } else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && getSymbol(root.parent.locals, candidate.escapedName, meaning) === candidate) {
+          error(errorLocation, Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), declarationNameToString(errorLocation));
+        }
+      }
+      if (errorLocation && meaning & 111551 /* Value */ && result.flags & 2097152 /* Alias */ && !(result.flags & 111551 /* Value */) && !isValidTypeOnlyAliasUseSite(errorLocation)) {
+        const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* Value */);
+        if (typeOnlyDeclaration) {
+          const message = typeOnlyDeclaration.kind === 281 /* ExportSpecifier */ || typeOnlyDeclaration.kind === 278 /* ExportDeclaration */ || typeOnlyDeclaration.kind === 280 /* NamespaceExport */ ? Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type : Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
+          const unescapedName = unescapeLeadingUnderscores(name);
+          addTypeOnlyDeclarationRelatedInfo(
+            error(errorLocation, message, unescapedName),
+            typeOnlyDeclaration,
+            unescapedName
+          );
         }
       }
-    }
-    function checkAndReportErrorForInvalidInitializer() {
-      if (propertyWithInvalidInitializer && !emitStandardClassFields) {
-        error(
-          errorLocation,
-          errorLocation && propertyWithInvalidInitializer.type && textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos) ? Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor : Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor,
-          declarationNameToString(propertyWithInvalidInitializer.name),
-          diagnosticName(nameArg)
-        );
-        return true;
-      }
-      return false;
-    }
-    if (!result) {
-      if (nameNotFoundMessage) {
-        addLazyDiagnostic(() => {
-          if (!errorLocation || errorLocation.parent.kind !== 324 /* JSDocLink */ && !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && // TODO: GH#18217
-          !checkAndReportErrorForInvalidInitializer() && !checkAndReportErrorForExtendingInterface(errorLocation) && !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) && !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
-            let suggestion;
-            let suggestedLib;
-            if (nameArg) {
-              suggestedLib = getSuggestedLibForNonExistentName(nameArg);
-              if (suggestedLib) {
-                error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib);
-              }
-            }
-            if (!suggestedLib && getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
-              suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
-              const isGlobalScopeAugmentationDeclaration = (suggestion == null ? void 0 : suggestion.valueDeclaration) && isAmbientModule(suggestion.valueDeclaration) && isGlobalScopeAugmentation(suggestion.valueDeclaration);
-              if (isGlobalScopeAugmentationDeclaration) {
-                suggestion = void 0;
-              }
-              if (suggestion) {
-                const suggestionName = symbolToString(suggestion);
-                const isUncheckedJS = isUncheckedJSSuggestion(
-                  originalLocation,
-                  suggestion,
-                  /*excludeClasses*/
-                  false
-                );
-                const message = meaning === 1920 /* Namespace */ || nameArg && typeof nameArg !== "string" && nodeIsSynthesized(nameArg) ? Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 : isUncheckedJS ? Diagnostics.Could_not_find_name_0_Did_you_mean_1 : Diagnostics.Cannot_find_name_0_Did_you_mean_1;
-                const diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName);
-                addErrorOrSuggestion(!isUncheckedJS, diagnostic);
-                if (suggestion.valueDeclaration) {
-                  addRelatedInfo(
-                    diagnostic,
-                    createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName)
-                  );
-                }
-              }
-            }
-            if (!suggestion && !suggestedLib && nameArg) {
-              error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
-            }
-            suggestionCount++;
-          }
-        });
-      }
-      return void 0;
-    } else if (nameNotFoundMessage && checkAndReportErrorForInvalidInitializer()) {
-      return void 0;
-    }
-    if (nameNotFoundMessage) {
-      addLazyDiagnostic(() => {
-        var _a2;
-        if (errorLocation && (meaning & 2 /* BlockScopedVariable */ || (meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */)) {
-          const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
-          if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
-            checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
-          }
-        }
-        if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 16777216 /* JSDoc */)) {
-          const merged = getMergedSymbol(result);
-          if (length(merged.declarations) && every(merged.declarations, (d) => isNamespaceExportDeclaration(d) || isSourceFile(d) && !!d.symbol.globalExports)) {
-            errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name));
-          }
-        }
-        if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* Value */) === 111551 /* Value */) {
-          const candidate = getMergedSymbol(getLateBoundSymbol(result));
-          const root = getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
-          if (candidate === getSymbolOfDeclaration(associatedDeclarationForContainingInitializerOrBindingName)) {
-            error(errorLocation, Diagnostics.Parameter_0_cannot_reference_itself, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
-          } else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) {
-            error(errorLocation, Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), declarationNameToString(errorLocation));
+      if (compilerOptions.isolatedModules && result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */) {
+        const isGlobal = getSymbol(globals, name, meaning) === result;
+        const nonValueSymbol = isGlobal && isSourceFile(lastLocation) && lastLocation.locals && getSymbol(lastLocation.locals, name, ~111551 /* Value */);
+        if (nonValueSymbol) {
+          const importDecl = (_a = nonValueSymbol.declarations) == null ? void 0 : _a.find((d) => d.kind === 276 /* ImportSpecifier */ || d.kind === 273 /* ImportClause */ || d.kind === 274 /* NamespaceImport */ || d.kind === 271 /* ImportEqualsDeclaration */);
+          if (importDecl && !isTypeOnlyImportDeclaration(importDecl)) {
+            error(importDecl, Diagnostics.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled, unescapeLeadingUnderscores(name));
           }
         }
-        if (result && errorLocation && meaning & 111551 /* Value */ && result.flags & 2097152 /* Alias */ && !(result.flags & 111551 /* Value */) && !isValidTypeOnlyAliasUseSite(errorLocation)) {
-          const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* Value */);
-          if (typeOnlyDeclaration) {
-            const message = typeOnlyDeclaration.kind === 281 /* ExportSpecifier */ || typeOnlyDeclaration.kind === 278 /* ExportDeclaration */ || typeOnlyDeclaration.kind === 280 /* NamespaceExport */ ? Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type : Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
-            const unescapedName = unescapeLeadingUnderscores(name);
-            addTypeOnlyDeclarationRelatedInfo(
-              error(errorLocation, message, unescapedName),
-              typeOnlyDeclaration,
-              unescapedName
-            );
-          }
-        }
-        if (compilerOptions.isolatedModules && result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */) {
-          const isGlobal = lookup(globals, name, meaning) === result;
-          const nonValueSymbol = isGlobal && isSourceFile(lastLocation) && lastLocation.locals && lookup(lastLocation.locals, name, ~111551 /* Value */);
-          if (nonValueSymbol) {
-            const importDecl = (_a2 = nonValueSymbol.declarations) == null ? void 0 : _a2.find((d) => d.kind === 276 /* ImportSpecifier */ || d.kind === 273 /* ImportClause */ || d.kind === 274 /* NamespaceImport */ || d.kind === 271 /* ImportEqualsDeclaration */);
-            if (importDecl && !isTypeOnlyImportDeclaration(importDecl)) {
-              error(importDecl, Diagnostics.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled, unescapeLeadingUnderscores(name));
-            }
-          }
-        }
-      });
-    }
-    return result;
+      }
+    });
   }
   function addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, unescapedName) {
     if (!typeOnlyDeclaration)
@@ -45584,47 +45763,9 @@ function createTypeChecker(host) {
       )
     );
   }
-  function getIsDeferredContext(location, lastLocation) {
-    if (location.kind !== 219 /* ArrowFunction */ && location.kind !== 218 /* FunctionExpression */) {
-      return isTypeQueryNode(location) || (isFunctionLikeDeclaration(location) || location.kind === 172 /* PropertyDeclaration */ && !isStatic(location)) && (!lastLocation || lastLocation !== location.name);
-    }
-    if (lastLocation && lastLocation === location.name) {
-      return false;
-    }
-    if (location.asteriskToken || hasSyntacticModifier(location, 1024 /* Async */)) {
-      return true;
-    }
-    return !getImmediatelyInvokedFunctionExpression(location);
-  }
-  function isSelfReferenceLocation(node) {
-    switch (node.kind) {
-      case 262 /* FunctionDeclaration */:
-      case 263 /* ClassDeclaration */:
-      case 264 /* InterfaceDeclaration */:
-      case 266 /* EnumDeclaration */:
-      case 265 /* TypeAliasDeclaration */:
-      case 267 /* ModuleDeclaration */:
-        return true;
-      default:
-        return false;
-    }
-  }
   function diagnosticName(nameArg) {
     return isString(nameArg) ? unescapeLeadingUnderscores(nameArg) : declarationNameToString(nameArg);
   }
-  function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
-    if (symbol.declarations) {
-      for (const decl of symbol.declarations) {
-        if (decl.kind === 168 /* TypeParameter */) {
-          const parent = isJSDocTemplateTag(decl.parent) ? getJSDocHost(decl.parent) : decl.parent;
-          if (parent === container) {
-            return !(isJSDocTemplateTag(decl.parent) && find(decl.parent.parent.tags, isJSDocTypeAlias));
-          }
-        }
-      }
-    }
-    return false;
-  }
   function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) {
     if (!isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) {
       return false;
@@ -45695,8 +45836,6 @@ function createTypeChecker(host) {
         788968 /* Type */ & ~namespaceMeaning,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false
       ));
@@ -45730,8 +45869,6 @@ function createTypeChecker(host) {
         ~788968 /* Type */ & 111551 /* Value */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false
       ));
@@ -45777,8 +45914,6 @@ function createTypeChecker(host) {
         788968 /* Type */ & ~111551 /* Value */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false
       ));
@@ -45830,8 +45965,6 @@ function createTypeChecker(host) {
         1024 /* NamespaceModule */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false
       ));
@@ -45850,8 +45983,6 @@ function createTypeChecker(host) {
         1536 /* Module */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false
       ));
@@ -45982,22 +46113,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) {
@@ -46056,7 +46193,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) {
@@ -46260,7 +46397,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);
           }
         }
@@ -46667,11 +46804,10 @@ function createTypeChecker(host) {
     let left = getFirstIdentifier(node);
     let symbol = resolveName(
       left,
-      left.escapedText,
+      left,
       111551 /* Value */,
       /*nameNotFoundMessage*/
       void 0,
-      left,
       /*isUse*/
       true
     );
@@ -46699,10 +46835,9 @@ function createTypeChecker(host) {
       const symbolFromJSPrototype = isInJSFile(name) && !nodeIsSynthesized(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : void 0;
       symbol = getMergedSymbol(resolveName(
         location || name,
-        name.escapedText,
+        name,
         meaning,
         ignoreErrors || symbolFromJSPrototype ? void 0 : message,
-        name,
         /*isUse*/
         true,
         /*excludeGlobals*/
@@ -46798,11 +46933,10 @@ function createTypeChecker(host) {
       if (secondaryLocation) {
         return resolveName(
           secondaryLocation,
-          name.escapedText,
+          name,
           meaning,
           /*nameNotFoundMessage*/
           void 0,
-          name,
           /*isUse*/
           true
         );
@@ -46893,7 +47027,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);
@@ -47138,7 +47272,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) {
@@ -47500,14 +47634,6 @@ function createTypeChecker(host) {
   function symbolIsValue(symbol, includeTypeOnlyMembers) {
     return !!(symbol.flags & 111551 /* Value */ || symbol.flags & 2097152 /* Alias */ && getSymbolFlags(symbol, !includeTypeOnlyMembers) & 111551 /* Value */);
   }
-  function findConstructorDeclaration(node) {
-    const members = node.members;
-    for (const member of members) {
-      if (member.kind === 176 /* Constructor */ && nodeIsPresent(member.body)) {
-        return member;
-      }
-    }
-  }
   function createType(flags) {
     var _a;
     const result = new Type7(checker, flags);
@@ -47989,8 +48115,6 @@ function createTypeChecker(host) {
       meaning,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       false
     );
@@ -49561,8 +49685,6 @@ function createTypeChecker(host) {
         111551 /* Value */ | 1048576 /* ExportValue */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         true
       );
@@ -49703,14 +49825,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);
@@ -49886,7 +50010,6 @@ function createTypeChecker(host) {
         788968 /* Type */,
         /*nameNotFoundMessage*/
         void 0,
-        escapedName,
         /*isUse*/
         false
       );
@@ -50447,22 +50570,16 @@ function createTypeChecker(host) {
           return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
         }
         function rewriteModuleSpecifier(parent, lit) {
-          if (context.bundled) {
-            if (context.tracker && context.tracker.moduleResolverHost) {
-              const targetFile = getExternalModuleFileFromDeclaration(parent);
-              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(parent);
+            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);
         }
       }
     }
@@ -52218,11 +52335,10 @@ function createTypeChecker(host) {
     if (node.parent && node.parent.kind === 277 /* ExportAssignment */) {
       exportSymbol = resolveName(
         node,
-        node.escapedText,
+        node,
         111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
         /*nameNotFoundMessage*/
         void 0,
-        node,
         /*isUse*/
         false
       );
@@ -52255,8 +52371,6 @@ function createTypeChecker(host) {
             111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */,
             /*nameNotFoundMessage*/
             void 0,
-            /*nameArg*/
-            void 0,
             /*isUse*/
             false
           );
@@ -56076,8 +56190,6 @@ function createTypeChecker(host) {
             111551 /* Value */,
             /*nameNotFoundMessage*/
             void 0,
-            /*nameArg*/
-            void 0,
             /*isUse*/
             false
           );
@@ -57111,12 +57223,9 @@ function createTypeChecker(host) {
       name,
       meaning,
       diagnostic,
-      name,
       /*isUse*/
       false,
       /*excludeGlobals*/
-      false,
-      /*getSpellingSuggestions*/
       false
     );
   }
@@ -64501,7 +64610,6 @@ function createTypeChecker(host) {
             788968 /* Type */,
             /*nameNotFoundMessage*/
             void 0,
-            param.name.escapedText,
             /*isUse*/
             true
           ) || originalKeywordKind && isTypeNodeKind(originalKeywordKind))) {
@@ -65723,10 +65831,9 @@ function createTypeChecker(host) {
     if (!links.resolvedSymbol) {
       links.resolvedSymbol = !nodeIsMissing(node) && resolveName(
         node,
-        node.escapedText,
+        node,
         111551 /* Value */ | 1048576 /* ExportValue */,
         getCannotFindNameDiagnosticForName(node),
-        node,
         !isWriteOnlyAccess(node),
         /*excludeGlobals*/
         false
@@ -68962,7 +69069,6 @@ function createTypeChecker(host) {
               111551 /* Value */,
               /*nameNotFoundMessage*/
               void 0,
-              id.escapedText,
               /*isUse*/
               true
             );
@@ -69012,8 +69118,6 @@ function createTypeChecker(host) {
       111551 /* Value */,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       true,
       /*excludeGlobals*/
@@ -70390,7 +70494,6 @@ function createTypeChecker(host) {
           1920 /* Namespace */,
           /*nameNotFoundMessage*/
           void 0,
-          namespaceName,
           /*isUse*/
           false
         );
@@ -70605,7 +70708,6 @@ function createTypeChecker(host) {
           jsxFactoryNamespace,
           111551 /* Value */,
           jsxFactoryRefErr,
-          jsxFactoryNamespace,
           /*isUse*/
           true
         );
@@ -70625,7 +70727,6 @@ function createTypeChecker(host) {
             localJsxNamespace,
             111551 /* Value */,
             jsxFactoryRefErr,
-            localJsxNamespace,
             /*isUse*/
             true
           );
@@ -71346,38 +71447,34 @@ function createTypeChecker(host) {
     const suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType);
     return suggestion && symbolName(suggestion);
   }
+  function getSuggestionForSymbolNameLookup(symbols, name, meaning) {
+    const symbol = getSymbol(symbols, name, meaning);
+    if (symbol)
+      return symbol;
+    let candidates;
+    if (symbols === globals) {
+      const primitives = mapDefined(
+        ["string", "number", "boolean", "object", "bigint", "symbol"],
+        (s) => symbols.has(s.charAt(0).toUpperCase() + s.slice(1)) ? createSymbol(524288 /* TypeAlias */, s) : void 0
+      );
+      candidates = primitives.concat(arrayFrom(symbols.values()));
+    } else {
+      candidates = arrayFrom(symbols.values());
+    }
+    return getSpellingSuggestionForName(unescapeLeadingUnderscores(name), candidates, meaning);
+  }
   function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) {
     Debug.assert(outerName !== void 0, "outername should always be defined");
-    const result = resolveNameHelper(
+    const result = resolveNameForSymbolSuggestion(
       location,
       outerName,
       meaning,
       /*nameNotFoundMessage*/
       void 0,
-      outerName,
       /*isUse*/
       false,
       /*excludeGlobals*/
-      false,
-      /*getSpellingSuggestions*/
-      true,
-      (symbols, name, meaning2) => {
-        Debug.assertEqual(outerName, name, "name should equal outerName");
-        const symbol = getSymbol(symbols, name, meaning2);
-        if (symbol)
-          return symbol;
-        let candidates;
-        if (symbols === globals) {
-          const primitives = mapDefined(
-            ["string", "number", "boolean", "object", "bigint", "symbol"],
-            (s) => symbols.has(s.charAt(0).toUpperCase() + s.slice(1)) ? createSymbol(524288 /* TypeAlias */, s) : void 0
-          );
-          candidates = primitives.concat(arrayFrom(symbols.values()));
-        } else {
-          candidates = arrayFrom(symbols.values());
-        }
-        return getSpellingSuggestionForName(unescapeLeadingUnderscores(name), candidates, meaning2);
-      }
+      false
     );
     return result;
   }
@@ -72234,8 +72331,6 @@ function createTypeChecker(host) {
       111551 /* Value */,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       false
     );
@@ -72575,6 +72670,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;
@@ -72609,7 +72705,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;
@@ -73499,8 +73597,6 @@ function createTypeChecker(host) {
       111551 /* Value */,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       false
     );
@@ -73557,7 +73653,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) {
@@ -73618,8 +73714,6 @@ function createTypeChecker(host) {
       111551 /* Value */,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       true
     );
@@ -75955,7 +76049,6 @@ function createTypeChecker(host) {
               788968 /* Type */,
               /*nameNotFoundMessage*/
               void 0,
-              name,
               /*isUse*/
               false
             );
@@ -78243,8 +78336,6 @@ function createTypeChecker(host) {
       meaning,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       true
     );
@@ -78899,7 +78990,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")) {
@@ -78996,8 +79087,6 @@ function createTypeChecker(host) {
         3 /* Variable */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         false
       );
@@ -80330,7 +80419,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 */) {
       error(name, Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ModuleKind[moduleKind]);
     }
   }
@@ -81400,7 +81489,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) {
             error(exportModifier, Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
@@ -81610,8 +81699,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 */) {
           error(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 */) {
+          error(node, Diagnostics.ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve);
         }
       }
       if (isImportSpecifier(node)) {
@@ -81653,7 +81744,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 */);
     }
   }
@@ -81674,7 +81765,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);
@@ -81707,7 +81798,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 {
@@ -81749,7 +81840,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);
         }
       }
@@ -81778,7 +81869,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 */);
@@ -81822,8 +81913,6 @@ function createTypeChecker(host) {
         111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
         /*nameNotFoundMessage*/
         void 0,
-        /*nameArg*/
-        void 0,
         /*isUse*/
         true
       );
@@ -81839,7 +81928,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 */);
       }
     }
@@ -81865,7 +81954,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(
@@ -81945,7 +82034,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);
@@ -83240,8 +83329,6 @@ function createTypeChecker(host) {
             111551 /* Value */,
             /*nameNotFoundMessage*/
             void 0,
-            /*nameArg*/
-            void 0,
             /*isUse*/
             false
           )) {
@@ -83633,8 +83720,6 @@ function createTypeChecker(host) {
       111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       true
     );
@@ -83650,13 +83735,9 @@ function createTypeChecker(host) {
       111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */,
       /*nameNotFoundMessage*/
       void 0,
-      /*nameArg*/
-      void 0,
       /*isUse*/
       true,
       /*excludeGlobals*/
-      void 0,
-      /*getSpellingSuggestions*/
       void 0
     );
   }
@@ -84334,7 +84415,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 */) {
@@ -85245,7 +85326,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);
@@ -85732,7 +85813,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 {
@@ -104978,6 +105061,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;
     }
@@ -105456,7 +105542,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;
@@ -108457,8 +108543,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);
@@ -108469,6 +108555,7 @@ function transformNodeModule(context) {
   const cjsTransform = transformModule(context);
   const cjsOnSubstituteNode = context.onSubstituteNode;
   const cjsOnEmitNode = context.onEmitNode;
+  const getEmitModuleFormatOfFile = (file) => context.getEmitHost().getEmitModuleFormatOfFile(file);
   context.onSubstituteNode = onSubstituteNode;
   context.onEmitNode = onEmitNode;
   context.enableSubstitution(307 /* SourceFile */);
@@ -108483,7 +108570,7 @@ function transformNodeModule(context) {
       if (!currentSourceFile) {
         return previousOnSubstituteNode(hint, node);
       }
-      if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
+      if (getEmitModuleFormatOfFile(currentSourceFile) >= 5 /* ES2015 */) {
         return esmOnSubstituteNode(hint, node);
       }
       return cjsOnSubstituteNode(hint, node);
@@ -108496,13 +108583,13 @@ function transformNodeModule(context) {
     if (!currentSourceFile) {
       return previousOnEmitNode(hint, node, emitCallback);
     }
-    if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
+    if (getEmitModuleFormatOfFile(currentSourceFile) >= 5 /* ES2015 */) {
       return esmOnEmitNode(hint, node, emitCallback);
     }
     return cjsOnEmitNode(hint, node, emitCallback);
   }
   function getModuleTransformForFile(file) {
-    return file.impliedNodeFormat === 99 /* ESNext */ ? esmTransform : cjsTransform;
+    return getEmitModuleFormatOfFile(file) >= 5 /* ES2015 */ ? esmTransform : cjsTransform;
   }
   function transformSourceFile(node) {
     if (node.isDeclarationFile) {
@@ -110405,17 +110492,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;
   }
@@ -111139,6 +111227,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,
@@ -111201,6 +111290,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,
@@ -116710,9 +116800,6 @@ function flattenDiagnosticMessageText(diag2, newLine, indent2 = 0) {
 function getModeForFileReference(ref, containingFileMode) {
   return (isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;
 }
-function getModeForResolutionAtIndex(file, index, compilerOptions) {
-  return getModeForUsageLocationWorker(file, getModuleNameStringLiteralAt(file, index), compilerOptions);
-}
 function isExclusivelyTypeOnlyImportOrExport(decl) {
   var _a;
   if (isExportDeclaration(decl)) {
@@ -116727,7 +116814,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) {
@@ -116743,20 +116829,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)
@@ -116816,7 +116910,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 {
@@ -117000,13 +117094,7 @@ function getConfigFileParsingDiagnostics(configFileParseResult) {
   return configFileParseResult.options.configFile ? [...configFileParseResult.options.configFile.parseDiagnostics, ...configFileParseResult.errors] : configFileParseResult.errors;
 }
 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 = [];
@@ -117456,7 +117544,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     isSourceFileFromExternalLibrary,
     isSourceFileDefaultLibrary,
     getModeForUsageLocation: getModeForUsageLocation2,
-    getModeForResolutionAtIndex: getModeForResolutionAtIndex2,
+    getEmitSyntaxForUsageLocation,
+    getModeForResolutionAtIndex,
     getSourceFileFromReference,
     getLibFileFromReference,
     sourceFileToPackageName,
@@ -117483,6 +117572,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     forEachResolvedProjectReference: forEachResolvedProjectReference2,
     isSourceOfProjectReferenceRedirect,
     getRedirectReferenceForResolutionFromSourceOfProject,
+    getCompilerOptionsForFile,
+    getDefaultResolutionModeForFile: getDefaultResolutionModeForFile2,
+    getEmitModuleFormatOfFile,
+    getImpliedNodeFormatForEmit,
+    shouldTransformImportCall,
     emitBuildInfo,
     fileExists,
     readFile,
@@ -118046,6 +118140,10 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       getSymlinkCache,
       writeFile: writeFileCallback || writeFile2,
       isEmitBlocked,
+      shouldTransformImportCall,
+      getEmitModuleFormatOfFile,
+      getDefaultResolutionModeForFile: getDefaultResolutionModeForFile2,
+      getModeForResolutionAtIndex,
       readFile: (f) => host.readFile(f),
       fileExists: (f) => {
         const path = toPath3(f);
@@ -119081,10 +119179,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 });
@@ -119232,13 +119334,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++) {
@@ -119774,7 +119875,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) {
@@ -120075,13 +120177,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 getModeForResolutionAtIndex2(file, index) {
+  function getEmitSyntaxForUsageLocation(file, usage) {
+    return getEmitSyntaxForUsageLocationWorker(file, usage, getCompilerOptionsForFile(file));
+  }
+  function getModeForResolutionAtIndex(file, index) {
     return getModeForUsageLocation2(file, getModuleNameStringLiteralAt(file, index));
   }
+  function getDefaultResolutionModeForFile2(sourceFile) {
+    return getDefaultResolutionModeForFileWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
+  }
+  function getImpliedNodeFormatForEmit(sourceFile) {
+    return getImpliedNodeFormatForEmitWorker(sourceFile, getCompilerOptionsForFile(sourceFile));
+  }
+  function getEmitModuleFormatOfFile(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;
@@ -122054,9 +122196,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,
@@ -122071,12 +122219,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;
@@ -122087,13 +122241,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) {
@@ -122108,7 +122278,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;
 }
@@ -122204,6 +122375,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,
@@ -122215,6 +122389,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolutionsWithOnlyAffectingLocations,
     directoryWatchesOfFailedLookups,
     fileWatchesOfAffectingLocations,
+    packageDirWatchers,
+    dirPathToSymlinkPackageRefCount,
     watchFailedLookupLocationsOfExternalModuleResolutions,
     getModuleResolutionCache: () => moduleResolutionCache,
     startRecordingFilesWithChangedResolutions,
@@ -122249,6 +122425,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();
@@ -122315,6 +122494,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     libraryResolutionCache.clearAllExceptPackageJsonInfoCache();
     nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
     nonRelativeExternalModuleResolutions.clear();
+    isSymlinkCache.clear();
   }
   function cleanupLibResolutionWatching(newProgram) {
     resolvedLibraries.forEach((resolution, libFileName) => {
@@ -122367,11 +122547,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) {
@@ -122621,12 +122808,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;
@@ -122650,6 +122838,10 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       setDirectoryWatcher(
         rootDir,
         rootPath,
+        /*packageDir*/
+        void 0,
+        /*packageDirPath*/
+        void 0,
         /*nonRecursive*/
         true
       );
@@ -122750,14 +122942,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);
@@ -122770,9 +123016,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);
       }
@@ -122994,7 +123258,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);
@@ -123200,10 +123464,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) {
@@ -123223,7 +123487,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(