typescript 5.0.0-dev.20221114 → 5.0.0-dev.20221116

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20221114`;
+var version = `${versionMajorMinor}.0-dev.20221116`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1294,15 +1294,9 @@ function isNodeLikeSystem() {
 // src/compiler/debug.ts
 var Debug;
 ((Debug2) => {
-  let typeScriptVersion2;
   let currentAssertionLevel = 0 /* None */;
   Debug2.currentLogLevel = 2 /* Warning */;
   Debug2.isDebugging = false;
-  Debug2.enableDeprecationWarnings = true;
-  function getTypeScriptVersion() {
-    return typeScriptVersion2 != null ? typeScriptVersion2 : typeScriptVersion2 = new Version(version);
-  }
-  Debug2.getTypeScriptVersion = getTypeScriptVersion;
   function shouldLog(level) {
     return Debug2.currentLogLevel <= level;
   }
@@ -1818,52 +1812,6 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
     isDebugInfoEnabled = true;
   }
   Debug2.enableDebugInfo = enableDebugInfo;
-  function formatDeprecationMessage(name, error, errorAfter, since, message) {
-    let deprecationMessage = error ? "DeprecationError: " : "DeprecationWarning: ";
-    deprecationMessage += `'${name}' `;
-    deprecationMessage += since ? `has been deprecated since v${since}` : "is deprecated";
-    deprecationMessage += error ? " and can no longer be used." : errorAfter ? ` and will no longer be usable after v${errorAfter}.` : ".";
-    deprecationMessage += message ? ` ${formatStringFromArgs(message, [name], 0)}` : "";
-    return deprecationMessage;
-  }
-  function createErrorDeprecation(name, errorAfter, since, message) {
-    const deprecationMessage = formatDeprecationMessage(name, true, errorAfter, since, message);
-    return () => {
-      throw new TypeError(deprecationMessage);
-    };
-  }
-  function createWarningDeprecation(name, errorAfter, since, message) {
-    let hasWrittenDeprecation = false;
-    return () => {
-      if (Debug2.enableDeprecationWarnings && !hasWrittenDeprecation) {
-        log.warn(formatDeprecationMessage(name, false, errorAfter, since, message));
-        hasWrittenDeprecation = true;
-      }
-    };
-  }
-  function createDeprecation(name, options = {}) {
-    var _a2, _b;
-    const version2 = typeof options.typeScriptVersion === "string" ? new Version(options.typeScriptVersion) : (_a2 = options.typeScriptVersion) != null ? _a2 : getTypeScriptVersion();
-    const errorAfter = typeof options.errorAfter === "string" ? new Version(options.errorAfter) : options.errorAfter;
-    const warnAfter = typeof options.warnAfter === "string" ? new Version(options.warnAfter) : options.warnAfter;
-    const since = typeof options.since === "string" ? new Version(options.since) : (_b = options.since) != null ? _b : warnAfter;
-    const error = options.error || errorAfter && version2.compareTo(errorAfter) <= 0;
-    const warn = !warnAfter || version2.compareTo(warnAfter) >= 0;
-    return error ? createErrorDeprecation(name, errorAfter, since, options.message) : warn ? createWarningDeprecation(name, errorAfter, since, options.message) : noop;
-  }
-  Debug2.createDeprecation = createDeprecation;
-  function wrapFunction(deprecation, func) {
-    return function() {
-      deprecation();
-      return func.apply(this, arguments);
-    };
-  }
-  function deprecate(func, options) {
-    var _a2;
-    const deprecation = createDeprecation((_a2 = options == null ? void 0 : options.name) != null ? _a2 : getFunctionName(func), options);
-    return wrapFunction(deprecation, func);
-  }
-  Debug2.deprecate = deprecate;
   function formatVariance(varianceFlags) {
     const variance = varianceFlags & 7 /* VarianceMask */;
     let result = variance === 0 /* Invariant */ ? "in out" : variance === 3 /* Bivariant */ ? "[bivariant]" : variance === 2 /* Contravariant */ ? "in" : variance === 1 /* Covariant */ ? "out" : variance === 4 /* Independent */ ? "[independent]" : "";
@@ -6776,10 +6724,10 @@ var Diagnostics = {
   Module_name_0_matched_pattern_1: diag(6092, 3 /* Message */, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."),
   Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, 3 /* Message */, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."),
   Resolving_module_name_0_relative_to_base_url_1_2: diag(6094, 3 /* Message */, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."),
-  Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1: diag(6095, 3 /* Message */, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1_6095", "Loading module as file / folder, candidate module location '{0}', target file type '{1}'."),
+  Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1: diag(6095, 3 /* Message */, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1_6095", "Loading module as file / folder, candidate module location '{0}', target file types: {1}."),
   File_0_does_not_exist: diag(6096, 3 /* Message */, "File_0_does_not_exist_6096", "File '{0}' does not exist."),
   File_0_exist_use_it_as_a_name_resolution_result: diag(6097, 3 /* Message */, "File_0_exist_use_it_as_a_name_resolution_result_6097", "File '{0}' exist - use it as a name resolution result."),
-  Loading_module_0_from_node_modules_folder_target_file_type_1: diag(6098, 3 /* Message */, "Loading_module_0_from_node_modules_folder_target_file_type_1_6098", "Loading module '{0}' from 'node_modules' folder, target file type '{1}'."),
+  Loading_module_0_from_node_modules_folder_target_file_types_Colon_1: diag(6098, 3 /* Message */, "Loading_module_0_from_node_modules_folder_target_file_types_Colon_1_6098", "Loading module '{0}' from 'node_modules' folder, target file types: {1}."),
   Found_package_json_at_0: diag(6099, 3 /* Message */, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."),
   package_json_does_not_have_a_0_field: diag(6100, 3 /* Message */, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."),
   package_json_has_0_field_1_that_references_2: diag(6101, 3 /* Message */, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."),
@@ -15134,6 +15082,7 @@ var supportedJSExtensionsFlat = flatten(supportedJSExtensions);
 var allSupportedExtensions = [[".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */, ".js" /* Js */, ".jsx" /* Jsx */], [".cts" /* Cts */, ".d.cts" /* Dcts */, ".cjs" /* Cjs */], [".mts" /* Mts */, ".d.mts" /* Dmts */, ".mjs" /* Mjs */]];
 var allSupportedExtensionsWithJson = [...allSupportedExtensions, [".json" /* Json */]];
 var supportedDeclarationExtensions = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */];
+var supportedTSImplementationExtensions = [".ts" /* Ts */, ".cts" /* Cts */, ".mts" /* Mts */, ".tsx" /* Tsx */];
 function getSupportedExtensions(options, extraFileExtensions) {
   const needJsExtensions = options && getAllowJSCompilerOption(options);
   if (!extraFileExtensions || extraFileExtensions.length === 0) {
@@ -21121,7 +21070,7 @@ var asyncDelegator = {
             var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
                 var i, p;
                 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-                function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+                function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
             };`
 };
 var asyncValues = {
@@ -32722,15 +32671,18 @@ function removeIgnoredPackageId(r) {
     return { path: r.path, ext: r.extension };
   }
 }
-var Extensions = /* @__PURE__ */ ((Extensions2) => {
-  Extensions2[Extensions2["TypeScript"] = 0] = "TypeScript";
-  Extensions2[Extensions2["JavaScript"] = 1] = "JavaScript";
-  Extensions2[Extensions2["Json"] = 2] = "Json";
-  Extensions2[Extensions2["TSConfig"] = 3] = "TSConfig";
-  Extensions2[Extensions2["DtsOnly"] = 4] = "DtsOnly";
-  Extensions2[Extensions2["TsOnly"] = 5] = "TsOnly";
-  return Extensions2;
-})(Extensions || {});
+function formatExtensions(extensions) {
+  const result = [];
+  if (extensions & 1 /* TypeScript */)
+    result.push("TypeScript");
+  if (extensions & 2 /* JavaScript */)
+    result.push("JavaScript");
+  if (extensions & 4 /* Declaration */)
+    result.push("Declaration");
+  if (extensions & 8 /* Json */)
+    result.push("JSON");
+  return result.join(", ");
+}
 function resolvedTypeScriptOnly(resolved) {
   if (!resolved) {
     return void 0;
@@ -32934,7 +32886,8 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
     features,
     conditions,
     requestContainingDirectory: containingDirectory,
-    reportDiagnostic: (diag2) => void diagnostics.push(diag2)
+    reportDiagnostic: (diag2) => void diagnostics.push(diag2),
+    isConfigLookup: false
   };
   let resolved = primaryLookup();
   let primary = true;
@@ -32984,7 +32937,7 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
         }
         return resolvedTypeScriptOnly(
           loadNodeModuleFromDirectory(
-            4 /* DtsOnly */,
+            4 /* Declaration */,
             candidate,
             !directoryExists,
             moduleResolutionState
@@ -33005,11 +32958,11 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
       }
       let result2;
       if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
-        const searchResult = loadModuleFromNearestNodeModulesDirectory(4 /* DtsOnly */, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, void 0, void 0);
+        const searchResult = loadModuleFromNearestNodeModulesDirectory(4 /* Declaration */, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, void 0, void 0);
         result2 = searchResult && searchResult.value;
       } else {
         const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
-        result2 = nodeLoadModuleByRelativeName(4 /* DtsOnly */, candidate, false, moduleResolutionState, true);
+        result2 = nodeLoadModuleByRelativeName(4 /* Declaration */, candidate, false, moduleResolutionState, true);
       }
       return resolvedTypeScriptOnly(result2);
     } else {
@@ -33525,38 +33478,42 @@ function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions,
     resolutionMode
   );
 }
-var jsOnlyExtensions = [1 /* JavaScript */];
-var tsExtensions = [0 /* TypeScript */, 1 /* JavaScript */];
-var tsPlusJsonExtensions = [...tsExtensions, 2 /* Json */];
-var tsconfigExtensions = [3 /* TSConfig */];
 function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
   const containingDirectory = getDirectoryPath(containingFile);
   const esmMode = resolutionMode === 99 /* ESNext */ ? 32 /* EsmMode */ : 0;
-  let extensions = compilerOptions.noDtsResolution ? [5 /* TsOnly */, 1 /* JavaScript */] : tsExtensions;
+  let extensions = compilerOptions.noDtsResolution ? 3 /* ImplementationFiles */ : 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */;
   if (compilerOptions.resolveJsonModule) {
-    extensions = [...extensions, 2 /* Json */];
+    extensions |= 8 /* Json */;
   }
-  return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference);
+  return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, false, redirectedReference);
 }
 function tryResolveJSModuleWorker(moduleName, initialDir, host) {
-  return nodeModuleNameResolverWorker(0 /* None */, moduleName, initialDir, { moduleResolution: 2 /* NodeJs */, allowJs: true }, host, void 0, jsOnlyExtensions, void 0);
+  return nodeModuleNameResolverWorker(
+    0 /* None */,
+    moduleName,
+    initialDir,
+    { moduleResolution: 2 /* NodeJs */, allowJs: true },
+    host,
+    void 0,
+    2 /* JavaScript */,
+    false,
+    void 0
+  );
 }
-function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
+function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, isConfigLookup) {
   let extensions;
-  if (lookupConfig) {
-    extensions = tsconfigExtensions;
+  if (isConfigLookup) {
+    extensions = 8 /* Json */;
   } else if (compilerOptions.noDtsResolution) {
-    extensions = [5 /* TsOnly */];
-    if (compilerOptions.allowJs)
-      extensions.push(1 /* JavaScript */);
+    extensions = 3 /* ImplementationFiles */;
     if (compilerOptions.resolveJsonModule)
-      extensions.push(2 /* Json */);
+      extensions |= 8 /* Json */;
   } else {
-    extensions = compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions;
+    extensions = compilerOptions.resolveJsonModule ? 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */ | 8 /* Json */ : 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */;
   }
-  return nodeModuleNameResolverWorker(0 /* None */, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, redirectedReference);
+  return nodeModuleNameResolverWorker(0 /* None */, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference);
 }
-function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
+function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, isConfigLookup, redirectedReference) {
   var _a2, _b;
   const traceEnabled = isTraceEnabled(compilerOptions, host);
   const failedLookupLocations = [];
@@ -33576,12 +33533,20 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
     features,
     conditions,
     requestContainingDirectory: containingDirectory,
-    reportDiagnostic: (diag2) => void diagnostics.push(diag2)
+    reportDiagnostic: (diag2) => void diagnostics.push(diag2),
+    isConfigLookup
   };
   if (traceEnabled && getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) <= 99 /* NodeNext */) {
     trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & 32 /* EsmMode */ ? "ESM" : "CJS", conditions.map((c) => `'${c}'`).join(", "));
   }
-  const result = forEach(extensions, (ext) => tryResolve(ext));
+  let result;
+  if (getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */) {
+    const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
+    const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
+    result = priorityExtensions && tryResolve(priorityExtensions) || secondaryExtensions && tryResolve(secondaryExtensions) || void 0;
+  } else {
+    result = tryResolve(extensions);
+  }
   return createResolvedModuleWithFailedLookupLocations(
     (_a2 = result == null ? void 0 : result.value) == null ? void 0 : _a2.resolved,
     (_b = result == null ? void 0 : result.value) == null ? void 0 : _b.isExternalLibraryImport,
@@ -33606,7 +33571,7 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
       }
       if (!resolved2) {
         if (traceEnabled) {
-          trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions2]);
+          trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
         }
         resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
       }
@@ -33647,7 +33612,7 @@ function realPath(path, host, traceEnabled) {
 }
 function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
   if (state.traceEnabled) {
-    trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]);
+    trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1, candidate, formatExtensions(extensions));
   }
   if (!hasTrailingDirectorySeparator(candidate)) {
     if (!onlyRecordFailures) {
@@ -33705,10 +33670,9 @@ function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures
   return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
 }
 function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
-  if (extensions === 2 /* Json */ || extensions === 3 /* TSConfig */) {
-    const extensionLess = tryRemoveExtension(candidate, ".json" /* Json */);
-    const extension = extensionLess ? candidate.substring(extensionLess.length) : "";
-    return extensionLess === void 0 && extensions === 2 /* Json */ ? void 0 : tryAddingExtensions(extensionLess || candidate, extensions, extension, onlyRecordFailures, state);
+  const resolvedByReplacingExtension = loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
+  if (resolvedByReplacingExtension) {
+    return resolvedByReplacingExtension;
   }
   if (!(state.features & 32 /* EsmMode */)) {
     const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, "", onlyRecordFailures, state);
@@ -33716,10 +33680,9 @@ function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
       return resolvedByAddingExtension;
     }
   }
-  return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
 }
 function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state) {
-  if (hasJSFileExtension(candidate) || fileExtensionIs(candidate, ".json" /* Json */) && state.compilerOptions.resolveJsonModule) {
+  if (hasJSFileExtension(candidate) || extensions & 8 /* Json */ && fileExtensionIs(candidate, ".json" /* Json */)) {
     const extensionless = removeFileExtension(candidate);
     const extension = candidate.substring(extensionless.length);
     if (state.traceEnabled) {
@@ -33729,7 +33692,7 @@ function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecor
   }
 }
 function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
-  if ((extensions === 0 /* TypeScript */ || extensions === 4 /* DtsOnly */) && fileExtensionIsOneOf(candidate, supportedTSExtensionsFlat)) {
+  if (extensions & 1 /* TypeScript */ && fileExtensionIsOneOf(candidate, supportedTSImplementationExtensions) || extensions & 4 /* Declaration */ && fileExtensionIsOneOf(candidate, supportedDeclarationExtensions)) {
     const result = tryFile(candidate, onlyRecordFailures, state);
     return result !== void 0 ? { path: candidate, ext: tryExtractTSExtension(candidate) } : void 0;
   }
@@ -33742,59 +33705,32 @@ function tryAddingExtensions(candidate, extensions, originalExtension, onlyRecor
       onlyRecordFailures = !directoryProbablyExists(directory, state.host);
     }
   }
-  switch (extensions) {
-    case 4 /* DtsOnly */:
-      switch (originalExtension) {
-        case ".mjs" /* Mjs */:
-        case ".mts" /* Mts */:
-        case ".d.mts" /* Dmts */:
-          return tryExtension(".d.mts" /* Dmts */);
-        case ".cjs" /* Cjs */:
-        case ".cts" /* Cts */:
-        case ".d.cts" /* Dcts */:
-          return tryExtension(".d.cts" /* Dcts */);
-        case ".json" /* Json */:
-          candidate += ".json" /* Json */;
-          return tryExtension(".d.ts" /* Dts */);
-        default:
-          return tryExtension(".d.ts" /* Dts */);
-      }
-    case 0 /* TypeScript */:
-    case 5 /* TsOnly */:
-      const useDts = extensions === 0 /* TypeScript */;
-      switch (originalExtension) {
-        case ".mjs" /* Mjs */:
-        case ".mts" /* Mts */:
-        case ".d.mts" /* Dmts */:
-          return tryExtension(".mts" /* Mts */) || (useDts ? tryExtension(".d.mts" /* Dmts */) : void 0);
-        case ".cjs" /* Cjs */:
-        case ".cts" /* Cts */:
-        case ".d.cts" /* Dcts */:
-          return tryExtension(".cts" /* Cts */) || (useDts ? tryExtension(".d.cts" /* Dcts */) : void 0);
-        case ".json" /* Json */:
-          candidate += ".json" /* Json */;
-          return useDts ? tryExtension(".d.ts" /* Dts */) : void 0;
-        default:
-          return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || (useDts ? tryExtension(".d.ts" /* Dts */) : void 0);
-      }
-    case 1 /* JavaScript */:
-      switch (originalExtension) {
-        case ".mjs" /* Mjs */:
-        case ".mts" /* Mts */:
-        case ".d.mts" /* Dmts */:
-          return tryExtension(".mjs" /* Mjs */);
-        case ".cjs" /* Cjs */:
-        case ".cts" /* Cts */:
-        case ".d.cts" /* Dcts */:
-          return tryExtension(".cjs" /* Cjs */);
-        case ".json" /* Json */:
-          return tryExtension(".json" /* Json */);
-        default:
-          return tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */);
+  switch (originalExtension) {
+    case ".mjs" /* Mjs */:
+    case ".mts" /* Mts */:
+    case ".d.mts" /* Dmts */:
+      return extensions & 1 /* TypeScript */ && tryExtension(".mts" /* Mts */) || extensions & 4 /* Declaration */ && tryExtension(".d.mts" /* Dmts */) || extensions & 2 /* JavaScript */ && tryExtension(".mjs" /* Mjs */) || void 0;
+    case ".cjs" /* Cjs */:
+    case ".cts" /* Cts */:
+    case ".d.cts" /* Dcts */:
+      return extensions & 1 /* TypeScript */ && tryExtension(".cts" /* Cts */) || extensions & 4 /* Declaration */ && tryExtension(".d.cts" /* Dcts */) || extensions & 2 /* JavaScript */ && tryExtension(".cjs" /* Cjs */) || void 0;
+    case ".json" /* Json */:
+      const originalCandidate = candidate;
+      if (extensions & 4 /* Declaration */) {
+        candidate += ".json" /* Json */;
+        const result = tryExtension(".d.ts" /* Dts */);
+        if (result)
+          return result;
       }
-    case 3 /* TSConfig */:
-    case 2 /* Json */:
-      return tryExtension(".json" /* Json */);
+      if (extensions & 8 /* Json */) {
+        candidate = originalCandidate;
+        const result = tryExtension(".json" /* Json */);
+        if (result)
+          return result;
+      }
+      return void 0;
+    default:
+      return extensions & 1 /* TypeScript */ && (tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */)) || extensions & 4 /* Declaration */ && tryExtension(".d.ts" /* Dts */) || extensions & 2 /* JavaScript */ && (tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */)) || state.isConfigLookup && tryExtension(".json" /* Json */) || void 0;
   }
   function tryExtension(ext) {
     const path = tryFile(candidate + ext, onlyRecordFailures, state);
@@ -33843,7 +33779,8 @@ function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options)
     features: 0 /* None */,
     conditions: emptyArray,
     requestContainingDirectory: void 0,
-    reportDiagnostic: noop
+    reportDiagnostic: noop,
+    isConfigLookup: false
   };
 }
 function getPackageScopeForPath(fileName, state) {
@@ -33902,23 +33839,10 @@ function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
 function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
   let packageFile;
   if (jsonContent) {
-    switch (extensions) {
-      case 1 /* JavaScript */:
-      case 2 /* Json */:
-      case 5 /* TsOnly */:
-        packageFile = readPackageJsonMainField(jsonContent, candidate, state);
-        break;
-      case 0 /* TypeScript */:
-        packageFile = readPackageJsonTypesFields(jsonContent, candidate, state) || readPackageJsonMainField(jsonContent, candidate, state);
-        break;
-      case 4 /* DtsOnly */:
-        packageFile = readPackageJsonTypesFields(jsonContent, candidate, state);
-        break;
-      case 3 /* TSConfig */:
-        packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
-        break;
-      default:
-        return Debug.assertNever(extensions);
+    if (state.isConfigLookup) {
+      packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
+    } else {
+      packageFile = extensions & 4 /* Declaration */ && readPackageJsonTypesFields(jsonContent, candidate, state) || extensions & (3 /* ImplementationFiles */ | 4 /* Declaration */) && readPackageJsonMainField(jsonContent, candidate, state) || void 0;
     }
   }
   const loader = (extensions2, candidate2, onlyRecordFailures2, state2) => {
@@ -33932,18 +33856,18 @@ function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFail
         trace(state2.host, Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile);
       }
     }
-    const nextExtensions = extensions2 === 4 /* DtsOnly */ ? 0 /* TypeScript */ : extensions2;
+    const expandedExtensions = extensions2 === 4 /* Declaration */ ? 1 /* TypeScript */ | 4 /* Declaration */ : extensions2;
     const features = state2.features;
     if ((jsonContent == null ? void 0 : jsonContent.type) !== "module") {
       state2.features &= ~32 /* EsmMode */;
     }
-    const result = nodeLoadModuleByRelativeName(nextExtensions, candidate2, onlyRecordFailures2, state2, false);
+    const result = nodeLoadModuleByRelativeName(expandedExtensions, candidate2, onlyRecordFailures2, state2, false);
     state2.features = features;
     return result;
   };
   const onlyRecordFailuresForPackageFile = packageFile ? !directoryProbablyExists(getDirectoryPath(packageFile), state.host) : void 0;
   const onlyRecordFailuresForIndex = onlyRecordFailures || !directoryProbablyExists(candidate, state.host);
-  const indexPath = combinePaths(candidate, extensions === 3 /* TSConfig */ ? "tsconfig" : "index");
+  const indexPath = combinePaths(candidate, state.isConfigLookup ? "tsconfig" : "index");
   if (versionPaths && (!packageFile || containsPath(candidate, packageFile))) {
     const moduleName = getRelativePathFromDirectory(candidate, packageFile || indexPath, false);
     if (state.traceEnabled) {
@@ -33966,19 +33890,7 @@ function resolvedIfExtensionMatches(extensions, path) {
   return ext !== void 0 && extensionIsOk(extensions, ext) ? { path, ext } : void 0;
 }
 function extensionIsOk(extensions, extension) {
-  switch (extensions) {
-    case 1 /* JavaScript */:
-      return extension === ".js" /* Js */ || extension === ".jsx" /* Jsx */ || extension === ".mjs" /* Mjs */ || extension === ".cjs" /* Cjs */;
-    case 3 /* TSConfig */:
-    case 2 /* Json */:
-      return extension === ".json" /* Json */;
-    case 0 /* TypeScript */:
-      return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */ || extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */;
-    case 5 /* TsOnly */:
-      return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */;
-    case 4 /* DtsOnly */:
-      return extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */;
-  }
+  return extensions & 2 /* JavaScript */ && (extension === ".js" /* Js */ || extension === ".jsx" /* Jsx */ || extension === ".mjs" /* Mjs */ || extension === ".cjs" /* Cjs */) || extensions & 1 /* TypeScript */ && (extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */) || extensions & 4 /* Declaration */ && (extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */) || extensions & 8 /* Json */ && extension === ".json" /* Json */ || false;
 }
 function parsePackageName(moduleName) {
   let idx = moduleName.indexOf(directorySeparator);
@@ -34140,7 +34052,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
           const combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath;
           traceIfEnabled(state, Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup);
           traceIfEnabled(state, Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/");
-          const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, [extensions], redirectedReference);
+          const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, false, redirectedReference);
           return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : void 0);
         }
         if (state.traceEnabled) {
@@ -34231,7 +34143,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
     }
     function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports2) {
       var _a2, _b, _c, _d;
-      if ((extensions === 0 /* TypeScript */ || extensions === 1 /* JavaScript */ || extensions === 2 /* Json */) && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && finalPath.indexOf("/node_modules/") === -1 && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames()) : true)) {
+      if (!state.isConfigLookup && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && finalPath.indexOf("/node_modules/") === -1 && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames()) : true)) {
         const getCanonicalFileName = hostGetCanonicalFileName({ useCaseSensitiveFileNames });
         const commonSourceDirGuesses = [];
         if (state.compilerOptions.rootDir || state.compilerOptions.composite && state.compilerOptions.configFilePath) {
@@ -34268,10 +34180,9 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
                 if (fileExtensionIs(possibleInputBase, ext)) {
                   const inputExts = getPossibleOriginalInputExtensionForExtension(possibleInputBase);
                   for (const possibleExt of inputExts) {
-                    const possibleInputWithInputExtension = changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
-                    if (extensions === 0 /* TypeScript */ && hasJSFileExtension(possibleInputWithInputExtension) || extensions === 1 /* JavaScript */ && hasTSFileExtension(possibleInputWithInputExtension)) {
+                    if (!extensionIsOk(extensions, possibleExt))
                       continue;
-                    }
+                    const possibleInputWithInputExtension = changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
                     if (state.host.fileExists(possibleInputWithInputExtension)) {
                       return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, false, state)));
                     }
@@ -34312,19 +34223,31 @@ function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, direc
   return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference);
 }
 function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) {
-  return loadModuleFromNearestNodeModulesDirectoryWorker(4 /* DtsOnly */, moduleName, directory, state, true, void 0, void 0);
+  return loadModuleFromNearestNodeModulesDirectoryWorker(4 /* Declaration */, moduleName, directory, state, true, void 0, void 0);
 }
 function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
   const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? void 0 : state.features & 32 /* EsmMode */ ? 99 /* ESNext */ : 1 /* CommonJS */, redirectedReference);
-  return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => {
-    if (getBaseFileName(ancestorDirectory) !== "node_modules") {
-      const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
-      if (resolutionFromCache) {
-        return resolutionFromCache;
+  const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
+  const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
+  if (priorityExtensions) {
+    const result = lookup(priorityExtensions);
+    if (result)
+      return result;
+  }
+  if (secondaryExtensions && !typesScopeOnly) {
+    return lookup(secondaryExtensions);
+  }
+  function lookup(extensions2) {
+    return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => {
+      if (getBaseFileName(ancestorDirectory) !== "node_modules") {
+        const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
+        if (resolutionFromCache) {
+          return resolutionFromCache;
+        }
+        return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
       }
-      return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
-    }
-  });
+    });
+  }
 }
 function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
   const nodeModulesFolder = combinePaths(directory, "node_modules");
@@ -34332,11 +34255,13 @@ function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, dir
   if (!nodeModulesFolderExists && state.traceEnabled) {
     trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
   }
-  const packageResult = typesScopeOnly ? void 0 : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference);
-  if (packageResult) {
-    return packageResult;
+  if (!typesScopeOnly) {
+    const packageResult = loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference);
+    if (packageResult) {
+      return packageResult;
+    }
   }
-  if (extensions === 0 /* TypeScript */ || extensions === 4 /* DtsOnly */) {
+  if (extensions & 4 /* Declaration */) {
     const nodeModulesAtTypes2 = combinePaths(nodeModulesFolder, "@types");
     let nodeModulesAtTypesExists = nodeModulesFolderExists;
     if (nodeModulesFolderExists && !directoryProbablyExists(nodeModulesAtTypes2, state.host)) {
@@ -34345,7 +34270,7 @@ function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, dir
       }
       nodeModulesAtTypesExists = false;
     }
-    return loadModuleFromSpecificNodeModulesDirectory(4 /* DtsOnly */, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference);
+    return loadModuleFromSpecificNodeModulesDirectory(4 /* Declaration */, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference);
   }
 }
 function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
@@ -34486,9 +34411,10 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
     features: 0 /* None */,
     conditions: [],
     requestContainingDirectory: containingDirectory,
-    reportDiagnostic: (diag2) => void diagnostics.push(diag2)
+    reportDiagnostic: (diag2) => void diagnostics.push(diag2),
+    isConfigLookup: false
   };
-  const resolved = tryResolve(0 /* TypeScript */) || tryResolve(1 /* JavaScript */);
+  const resolved = tryResolve(1 /* TypeScript */ | 4 /* Declaration */) || tryResolve(2 /* JavaScript */ | (compilerOptions.resolveJsonModule ? 8 /* Json */ : 0));
   return createResolvedModuleWithFailedLookupLocations(
     resolved && resolved.value,
     false,
@@ -34515,7 +34441,7 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
       if (resolved2) {
         return resolved2;
       }
-      if (extensions === 0 /* TypeScript */) {
+      if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
         return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
       }
     } else {
@@ -34542,9 +34468,10 @@ function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, hos
     features: 0 /* None */,
     conditions: [],
     requestContainingDirectory: void 0,
-    reportDiagnostic: (diag2) => void diagnostics.push(diag2)
+    reportDiagnostic: (diag2) => void diagnostics.push(diag2),
+    isConfigLookup: false
   };
-  const resolved = loadModuleFromImmediateNodeModulesDirectory(4 /* DtsOnly */, moduleName, globalCache, state, false, void 0, void 0);
+  const resolved = loadModuleFromImmediateNodeModulesDirectory(4 /* Declaration */, moduleName, globalCache, state, false, void 0, void 0);
   return createResolvedModuleWithFailedLookupLocations(
     resolved,
     true,
@@ -37494,6 +37421,7 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
   const importedFileIsInNodeModules = some(modulePaths, (p) => p.isInNodeModules);
   let nodeModulesSpecifiers;
   let pathsSpecifiers;
+  let redirectPathsSpecifiers;
   let relativeSpecifiers;
   for (const modulePath of modulePaths) {
     const specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, void 0, options.overrideImportMode);
@@ -37501,60 +37429,77 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
     if (specifier && modulePath.isRedirect) {
       return nodeModulesSpecifiers;
     }
-    if (!specifier && !modulePath.isRedirect) {
-      const local = getLocalModuleSpecifier(modulePath.path, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
-      if (pathIsBareSpecifier(local)) {
+    if (!specifier) {
+      const local = getLocalModuleSpecifier(
+        modulePath.path,
+        info,
+        compilerOptions,
+        host,
+        options.overrideImportMode || importingSourceFile.impliedNodeFormat,
+        preferences,
+        modulePath.isRedirect
+      );
+      if (!local) {
+        continue;
+      }
+      if (modulePath.isRedirect) {
+        redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
+      } else if (pathIsBareSpecifier(local)) {
         pathsSpecifiers = append(pathsSpecifiers, local);
       } else if (!importedFileIsInNodeModules || modulePath.isInNodeModules) {
         relativeSpecifiers = append(relativeSpecifiers, local);
       }
     }
   }
-  return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers : Debug.checkDefined(relativeSpecifiers);
+  return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? redirectPathsSpecifiers : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers : Debug.checkDefined(relativeSpecifiers);
 }
 function getInfo(importingSourceFileName, host) {
   const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true);
   const sourceDirectory = getDirectoryPath(importingSourceFileName);
   return { getCanonicalFileName, importingSourceFileName, sourceDirectory };
 }
-function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { ending, relativePreference }) {
+function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { ending, relativePreference }, pathsOnly) {
   const { baseUrl, paths, rootDirs } = compilerOptions;
+  if (pathsOnly && !paths) {
+    return void 0;
+  }
   const { sourceDirectory, getCanonicalFileName } = info;
   const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) || removeExtensionAndIndexPostFix(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions);
   if (!baseUrl && !paths || relativePreference === 0 /* Relative */) {
-    return relativePath;
+    return pathsOnly ? void 0 : relativePath;
   }
   const baseDirectory = getNormalizedAbsolutePath(getPathsBasePath(compilerOptions, host) || baseUrl, host.getCurrentDirectory());
   const relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseDirectory, getCanonicalFileName);
   if (!relativeToBaseUrl) {
-    return relativePath;
+    return pathsOnly ? void 0 : relativePath;
   }
   const fromPaths = paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, getAllowedEndings(ending, compilerOptions, importMode), host, compilerOptions);
-  const nonRelative = fromPaths === void 0 && baseUrl !== void 0 ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths;
-  if (!nonRelative) {
+  if (pathsOnly) {
+    return fromPaths;
+  }
+  const maybeNonRelative = fromPaths === void 0 && baseUrl !== void 0 ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths;
+  if (!maybeNonRelative) {
     return relativePath;
   }
-  if (relativePreference === 1 /* NonRelative */) {
-    return nonRelative;
+  if (relativePreference === 1 /* NonRelative */ && !pathIsRelative(maybeNonRelative)) {
+    return maybeNonRelative;
   }
-  if (relativePreference === 3 /* ExternalNonRelative */) {
+  if (relativePreference === 3 /* ExternalNonRelative */ && !pathIsRelative(maybeNonRelative)) {
     const projectDirectory = compilerOptions.configFilePath ? toPath(getDirectoryPath(compilerOptions.configFilePath), host.getCurrentDirectory(), info.getCanonicalFileName) : info.getCanonicalFileName(host.getCurrentDirectory());
     const modulePath = toPath(moduleFileName, projectDirectory, getCanonicalFileName);
     const sourceIsInternal = startsWith(sourceDirectory, projectDirectory);
     const targetIsInternal = startsWith(modulePath, projectDirectory);
     if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) {
-      return nonRelative;
+      return maybeNonRelative;
     }
     const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
     const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
     if (nearestSourcePackageJson !== nearestTargetPackageJson) {
-      return nonRelative;
+      return maybeNonRelative;
     }
     return relativePath;
   }
-  if (relativePreference !== 2 /* Shortest */)
-    Debug.assertNever(relativePreference);
-  return isPathRelativeToParent(nonRelative) || countPathComponents(relativePath) < countPathComponents(nonRelative) ? relativePath : nonRelative;
+  return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
 }
 function countPathComponents(path) {
   let count = 0;
@@ -41783,25 +41728,22 @@ function createTypeChecker(host) {
       const context = {
         enclosingDeclaration,
         flags: flags || 0 /* None */,
-        tracker: tracker && tracker.trackSymbol ? tracker : {
-          trackSymbol: () => false,
-          moduleResolverHost: flags & 134217728 /* DoNotIncludeSymbolChain */ ? {
-            getCommonSourceDirectory: !!host.getCommonSourceDirectory ? () => host.getCommonSourceDirectory() : () => "",
-            getCurrentDirectory: () => host.getCurrentDirectory(),
-            getSymlinkCache: maybeBind(host, host.getSymlinkCache),
-            getPackageJsonInfoCache: () => {
-              var _a3;
-              return (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host);
-            },
-            useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
-            redirectTargetsMap: host.redirectTargetsMap,
-            getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
-            isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
-            fileExists: (fileName) => host.fileExists(fileName),
-            getFileIncludeReasons: () => host.getFileIncludeReasons(),
-            readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
-          } : void 0
-        },
+        tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: () => false, moduleResolverHost: flags & 134217728 /* DoNotIncludeSymbolChain */ ? {
+          getCommonSourceDirectory: !!host.getCommonSourceDirectory ? () => host.getCommonSourceDirectory() : () => "",
+          getCurrentDirectory: () => host.getCurrentDirectory(),
+          getSymlinkCache: maybeBind(host, host.getSymlinkCache),
+          getPackageJsonInfoCache: () => {
+            var _a3;
+            return (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host);
+          },
+          useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
+          redirectTargetsMap: host.redirectTargetsMap,
+          getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
+          isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
+          fileExists: (fileName) => host.fileExists(fileName),
+          getFileIncludeReasons: () => host.getFileIncludeReasons(),
+          readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
+        } : void 0 },
         encounteredError: false,
         reportedDiagnostic: false,
         visitedTypes: void 0,
@@ -68177,8 +68119,9 @@ function createTypeChecker(host) {
     });
     const containsArguments = containsArgumentsReference(node);
     if (containsArguments) {
-      const lastJSDocParam = lastOrUndefined(jsdocParameters);
-      if (isJs && lastJSDocParam && isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
+      const lastJSDocParamIndex = jsdocParameters.length - 1;
+      const lastJSDocParam = jsdocParameters[lastJSDocParamIndex];
+      if (isJs && lastJSDocParam && isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !excludedParameters.has(lastJSDocParamIndex) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
         error(lastJSDocParam.name, Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, idText(lastJSDocParam.name));
       }
     } else {
@@ -74191,10 +74134,10 @@ var visitEachChildTable = {
       nodeVisitor(node.initializer, visitor, isExpression)
     );
   },
-  [308 /* SourceFile */]: function visitEachChildOfSourceFile(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+  [308 /* SourceFile */]: function visitEachChildOfSourceFile(node, visitor, context, _nodesVisitor, _nodeVisitor, _tokenVisitor) {
     return context.factory.updateSourceFile(
       node,
-      visitLexicalEnvironment(node.statements, visitor, context, void 0, void 0, nodesVisitor)
+      visitLexicalEnvironment(node.statements, visitor, context)
     );
   },
   [353 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
@@ -92162,7 +92105,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
         const sourceMap = sourceMapGenerator.toString();
         writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
         if (printer.bundleFileInfo)
-          printer.bundleFileInfo.mapHash = computeSignature(sourceMap, maybeBind(host, host.createHash));
+          printer.bundleFileInfo.mapHash = computeSignature(sourceMap, host);
       }
     } else {
       writer.writeLine();
@@ -92170,7 +92113,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
     const text = writer.getText();
     writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos, diagnostics: transform.diagnostics });
     if (printer.bundleFileInfo)
-      printer.bundleFileInfo.hash = computeSignature(text, maybeBind(host, host.createHash));
+      printer.bundleFileInfo.hash = computeSignature(text, host);
     writer.clear();
   }
   function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) {
@@ -92316,7 +92259,6 @@ function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
   return result;
 }
 function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers) {
-  const createHash = maybeBind(host, host.createHash);
   const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, false);
   const buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
   if (!buildInfo)
@@ -92326,22 +92268,22 @@ function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransforme
   const jsFileText = host.readFile(Debug.checkDefined(jsFilePath));
   if (!jsFileText)
     return jsFilePath;
-  if (computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
+  if (computeSignature(jsFileText, host) !== buildInfo.bundle.js.hash)
     return jsFilePath;
   const sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
   if (sourceMapFilePath && !sourceMapText || config.options.inlineSourceMap)
     return sourceMapFilePath || "inline sourcemap decoding";
-  if (sourceMapFilePath && computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
+  if (sourceMapFilePath && computeSignature(sourceMapText, host) !== buildInfo.bundle.js.mapHash)
     return sourceMapFilePath;
   const declarationText = declarationFilePath && host.readFile(declarationFilePath);
   if (declarationFilePath && !declarationText)
     return declarationFilePath;
-  if (declarationFilePath && computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
+  if (declarationFilePath && computeSignature(declarationText, host) !== buildInfo.bundle.dts.hash)
     return declarationFilePath;
   const declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
   if (declarationMapPath && !declarationMapText || config.options.inlineSourceMap)
     return declarationMapPath || "inline sourcemap decoding";
-  if (declarationMapPath && computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
+  if (declarationMapPath && computeSignature(declarationMapText, host) !== buildInfo.bundle.dts.mapHash)
     return declarationMapPath;
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
   const ownPrependInput = createInputFilesWithFileTexts(
@@ -92411,7 +92353,7 @@ function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransforme
     getBuildInfo: (bundle) => {
       const program = buildInfo.program;
       if (program && changedDtsText !== void 0 && config.options.composite) {
-        program.outSignature = computeSignature(changedDtsText, createHash, changedDtsData);
+        program.outSignature = computeSignature(changedDtsText, host, changedDtsData);
       }
       const { js, dts, sourceFiles } = buildInfo.bundle;
       bundle.js.sources = js.sources;
@@ -92424,7 +92366,7 @@ function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransforme
     getSourceFileFromReference: returnUndefined,
     redirectTargetsMap: createMultiMap(),
     getFileIncludeReasons: notImplemented,
-    createHash
+    createHash: maybeBind(host, host.createHash)
   };
   emitFiles(
     notImplementedResolver,
@@ -100481,7 +100423,7 @@ var BuilderState;
     return oldState && !oldState.referencedMap === !newReferencedMap;
   }
   BuilderState2.canReuseOldState = canReuseOldState;
-  function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
+  function create(newProgram, oldState, disableUseFileVersionAsSignature) {
     var _a2, _b, _c;
     const fileInfos = /* @__PURE__ */ new Map();
     const options = newProgram.getCompilerOptions();
@@ -100489,6 +100431,7 @@ var BuilderState;
     const referencedMap = options.module !== 0 /* None */ && !isOutFile ? createManyToManyPathMap() : void 0;
     const exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
     const useOldState = canReuseOldState(referencedMap, oldState);
+    const getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames());
     newProgram.getTypeChecker();
     for (const sourceFile of newProgram.getSourceFiles()) {
       const version2 = Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
@@ -100527,30 +100470,29 @@ var BuilderState;
     state.allFileNames = void 0;
   }
   BuilderState2.releaseCache = releaseCache2;
-  function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
+  function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
     var _a2, _b;
     const result = getFilesAffectedByWithOldState(
       state,
       programOfThisState,
       path,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName
+      host
     );
     (_a2 = state.oldSignatures) == null ? void 0 : _a2.clear();
     (_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
     return result;
   }
   BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
-  function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
+  function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host) {
     const sourceFile = programOfThisState.getSourceFileByPath(path);
     if (!sourceFile) {
       return emptyArray;
     }
-    if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
+    if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host)) {
       return [sourceFile];
     }
-    return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName);
+    return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
   }
   BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
   function updateSignatureOfFile(state, signature, path) {
@@ -100558,7 +100500,7 @@ var BuilderState;
     (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path);
   }
   BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
-  function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName, useFileVersionAsSignature = state.useFileVersionAsSignature) {
+  function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host, useFileVersionAsSignature = state.useFileVersionAsSignature) {
     var _a2;
     if ((_a2 = state.hasCalledUpdateShapeSignature) == null ? void 0 : _a2.has(sourceFile.resolvedPath))
       return false;
@@ -100571,10 +100513,10 @@ var BuilderState;
         (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) => {
           Debug.assert(isDeclarationFileName(fileName), `File extension for signature expected to be dts: Got:: ${fileName}`);
           latestSignature = computeSignatureWithDiagnostics(
+            programOfThisState,
             sourceFile,
             text,
-            computeHash,
-            getCanonicalFileName,
+            host,
             data
           );
           if (latestSignature !== prevSignature) {
@@ -100713,7 +100655,7 @@ var BuilderState;
     }
     return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
   }
-  function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash, getCanonicalFileName) {
+  function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, host) {
     if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
       return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
     }
@@ -100729,7 +100671,7 @@ var BuilderState;
       if (!seenFileNamesMap.has(currentPath)) {
         const currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
         seenFileNamesMap.set(currentPath, currentSourceFile);
-        if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
+        if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, host)) {
           queue.push(...getReferencedByPaths(state, currentSourceFile.resolvedPath));
         }
       }
@@ -100771,9 +100713,9 @@ function getPendingEmitKind(optionsOrEmitKind, oldOptionsOrEmitKind) {
 function hasSameKeys(map1, map2) {
   return map1 === map2 || map1 !== void 0 && map2 !== void 0 && map1.size === map2.size && !forEachKey(map1, (key) => !map2.has(key));
 }
-function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
+function createBuilderProgramState(newProgram, oldState, disableUseFileVersionAsSignature) {
   var _a2, _b;
-  const state = BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature);
+  const state = BuilderState.create(newProgram, oldState, disableUseFileVersionAsSignature);
   state.program = newProgram;
   const compilerOptions = newProgram.getCompilerOptions();
   state.compilerOptions = compilerOptions;
@@ -100817,7 +100759,7 @@ function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, d
         return;
       const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
       if (diagnostics) {
-        state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) : diagnostics);
+        state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : diagnostics);
         if (!state.semanticDiagnosticsFromOldState) {
           state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set();
         }
@@ -100877,10 +100819,11 @@ function addFileToChangeSet(state, path) {
 function getEmitSignatureFromOldSignature(options, oldOptions, oldEmitSignature) {
   return !!options.declarationMap === !!oldOptions.declarationMap ? oldEmitSignature : isString(oldEmitSignature) ? [oldEmitSignature] : oldEmitSignature[0];
 }
-function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
+function convertToDiagnostics(diagnostics, newProgram) {
   if (!diagnostics.length)
     return emptyArray;
-  const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
+  let buildInfoDirectory;
+  let getCanonicalFileName;
   return diagnostics.map((diagnostic) => {
     const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3);
     result.reportsUnnecessary = diagnostic.reportsUnnecessary;
@@ -100892,7 +100835,8 @@ function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
     return result;
   });
   function toPath3(path) {
-    return toPath(path, buildInfoDirectory, getCanonicalFileName);
+    buildInfoDirectory != null ? buildInfoDirectory : buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
+    return toPath(path, buildInfoDirectory, getCanonicalFileName != null ? getCanonicalFileName : getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames()));
   }
 }
 function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3) {
@@ -100934,7 +100878,7 @@ function restoreBuilderProgramEmitState(state, savedEmitState) {
 function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
   Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
 }
-function getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host) {
+function getNextAffectedFile(state, cancellationToken, host) {
   var _a2, _b;
   while (true) {
     const { affectedFiles } = state;
@@ -100950,8 +100894,6 @@ function getNextAffectedFile(state, cancellationToken, computeHash, getCanonical
             state,
             affectedFile,
             cancellationToken,
-            computeHash,
-            getCanonicalFileName,
             host
           );
           return affectedFile;
@@ -100979,8 +100921,7 @@ function getNextAffectedFile(state, cancellationToken, computeHash, getCanonical
       program,
       nextKey.value,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName
+      host
     );
     state.currentChangedFilePath = nextKey.value;
     state.affectedFilesIndex = 0;
@@ -101032,7 +100973,7 @@ function removeDiagnosticsOfLibraryFiles(state) {
     );
   }
 }
-function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
+function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host) {
   removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
   if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
     removeDiagnosticsOfLibraryFiles(state);
@@ -101041,8 +100982,7 @@ function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken
       Debug.checkDefined(state.program),
       affectedFile,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName
+      host
     );
     return;
   }
@@ -101052,12 +100992,10 @@ function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken
     state,
     affectedFile,
     cancellationToken,
-    computeHash,
-    getCanonicalFileName,
     host
   );
 }
-function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCanonicalFileName, host) {
+function handleDtsMayChangeOf(state, path, cancellationToken, host) {
   removeSemanticDiagnosticsOf(state, path);
   if (!state.changedFilesSet.has(path)) {
     const program = Debug.checkDefined(state.program);
@@ -101068,8 +101006,7 @@ function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCa
         program,
         sourceFile,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName,
+        host,
         !host.disableUseFileVersionAsSignature
       );
       if (getEmitDeclarations(state.compilerOptions)) {
@@ -101091,7 +101028,7 @@ function isChangedSignature(state, path) {
   const newSignature = Debug.checkDefined(state.fileInfos.get(path)).signature;
   return newSignature !== oldSignature;
 }
-function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host) {
+function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host) {
   var _a2;
   if (!((_a2 = state.fileInfos.get(filePath)) == null ? void 0 : _a2.affectsGlobalScope))
     return false;
@@ -101099,14 +101036,12 @@ function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, com
     state,
     file.resolvedPath,
     cancellationToken,
-    computeHash,
-    getCanonicalFileName,
     host
   ));
   removeDiagnosticsOfLibraryFiles(state);
   return true;
 }
-function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
+function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
   var _a2;
   if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
     return;
@@ -101120,9 +101055,9 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
       const currentPath = queue.pop();
       if (!seenFileNamesMap.has(currentPath)) {
         seenFileNamesMap.set(currentPath, true);
-        if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host))
+        if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, host))
           return;
-        handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host);
+        handleDtsMayChangeOf(state, currentPath, cancellationToken, host);
         if (isChangedSignature(state, currentPath)) {
           const currentSourceFile = Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
           queue.push(...BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
@@ -101132,7 +101067,7 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
   }
   const seenFileAndExportsOfFile = /* @__PURE__ */ new Set();
   (_a2 = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a2.forEach((exportedFromPath) => {
-    if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, getCanonicalFileName, host))
+    if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
       return true;
     const references = state.referencedMap.getKeys(exportedFromPath);
     return references && forEachKey(
@@ -101142,28 +101077,24 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
         filePath,
         seenFileAndExportsOfFile,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName,
         host
       )
     );
   });
 }
-function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host) {
+function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
   var _a2, _b;
   if (!tryAddToSet(seenFileAndExportsOfFile, filePath))
     return void 0;
-  if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host))
+  if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
     return true;
-  handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host);
+  handleDtsMayChangeOf(state, filePath, cancellationToken, host);
   (_a2 = state.exportedModulesMap.getKeys(filePath)) == null ? void 0 : _a2.forEach(
     (exportedFromPath) => handleDtsMayChangeOfFileAndExportsOfFile(
       state,
       exportedFromPath,
       seenFileAndExportsOfFile,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName,
       host
     )
   );
@@ -101172,8 +101103,6 @@ function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndEx
       state,
       referencingFilePath,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName,
       host
     )
   );
@@ -101202,9 +101131,10 @@ function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationTok
 function isProgramBundleEmitBuildInfo(info) {
   return !!outFile(info.options || {});
 }
-function getBuildInfo2(state, getCanonicalFileName, bundle) {
+function getBuildInfo2(state, bundle) {
   var _a2, _b, _c;
   const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();
+  const getCanonicalFileName = createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
   const latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : void 0;
   const fileNames = [];
@@ -101423,8 +101353,9 @@ function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldP
 function getTextHandlingSourceMapForSignature(text, data) {
   return (data == null ? void 0 : data.sourceMapUrlPos) !== void 0 ? text.substring(0, data.sourceMapUrlPos) : text;
 }
-function computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data) {
-  var _a2;
+function computeSignatureWithDiagnostics(program, sourceFile, text, host, data) {
+  var _a2, _b;
+  let getCanonicalFileName;
   text = getTextHandlingSourceMapForSignature(text, data);
   let sourceFileDirectory;
   if ((_a2 = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a2.length) {
@@ -101432,7 +101363,7 @@ function computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanon
       (diagnostic) => `${locationInfo(diagnostic)}${DiagnosticCategory[diagnostic.category]}${diagnostic.code}: ${flattenDiagnosticMessageText2(diagnostic.messageText)}`
     ).join("\n");
   }
-  return (computeHash != null ? computeHash : generateDjb2Hash)(text);
+  return ((_b = host.createHash) != null ? _b : generateDjb2Hash)(text);
   function flattenDiagnosticMessageText2(diagnostic) {
     return isString(diagnostic) ? diagnostic : diagnostic === void 0 ? "" : !diagnostic.next ? diagnostic.messageText : diagnostic.messageText + diagnostic.next.map(flattenDiagnosticMessageText2).join("\n");
   }
@@ -101441,11 +101372,16 @@ function computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanon
       return `(${diagnostic.start},${diagnostic.length})`;
     if (sourceFileDirectory === void 0)
       sourceFileDirectory = getDirectoryPath(sourceFile.resolvedPath);
-    return `${ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceFileDirectory, diagnostic.file.resolvedPath, getCanonicalFileName))}(${diagnostic.start},${diagnostic.length})`;
+    return `${ensurePathIsNonModuleName(getRelativePathFromDirectory(
+      sourceFileDirectory,
+      diagnostic.file.resolvedPath,
+      getCanonicalFileName != null ? getCanonicalFileName : getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames())
+    ))}(${diagnostic.start},${diagnostic.length})`;
   }
 }
-function computeSignature(text, computeHash, data) {
-  return (computeHash != null ? computeHash : generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
+function computeSignature(text, host, data) {
+  var _a2;
+  return ((_a2 = host.createHash) != null ? _a2 : generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
 }
 function createBuilderProgram(kind, { newProgram, host, oldProgram, configFileParsingDiagnostics }) {
   let oldState = oldProgram && oldProgram.getState();
@@ -101454,10 +101390,8 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
     oldState = void 0;
     return oldProgram;
   }
-  const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
-  const computeHash = maybeBind(host, host.createHash);
-  const state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
-  newProgram.getBuildInfo = (bundle) => getBuildInfo2(state, getCanonicalFileName, bundle);
+  const state = createBuilderProgramState(newProgram, oldState, host.disableUseFileVersionAsSignature);
+  newProgram.getBuildInfo = (bundle) => getBuildInfo2(state, bundle);
   newProgram = void 0;
   oldProgram = void 0;
   oldState = void 0;
@@ -101491,7 +101425,7 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
   }
   function emitNextAffectedFile(writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
     var _a2, _b, _c, _d, _e;
-    let affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
+    let affected = getNextAffectedFile(state, cancellationToken, host);
     const programEmitKind = getBuilderFileEmit(state.compilerOptions);
     let emitKind = emitOnlyDtsFiles ? programEmitKind & 24 /* AllDts */ : programEmitKind;
     if (!affected) {
@@ -101565,10 +101499,10 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
             const info = state.fileInfos.get(file.resolvedPath);
             if (info.signature === file.version) {
               const signature = computeSignatureWithDiagnostics(
+                state.program,
                 file,
                 text,
-                computeHash,
-                getCanonicalFileName,
+                host,
                 data
               );
               if (!((_a2 = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a2.length))
@@ -101612,7 +101546,7 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
         state.program.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
       function handleNewSignature(oldSignatureFormat, newSignature) {
         const oldSignature = !oldSignatureFormat || isString(oldSignatureFormat) ? oldSignatureFormat : oldSignatureFormat[0];
-        newSignature != null ? newSignature : newSignature = computeSignature(text, computeHash, data);
+        newSignature != null ? newSignature : newSignature = computeSignature(text, host, data);
         if (newSignature === oldSignature) {
           if (oldSignatureFormat === oldSignature)
             return void 0;
@@ -101668,7 +101602,7 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
   }
   function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
     while (true) {
-      const affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
+      const affected = getNextAffectedFile(state, cancellationToken, host);
       let result;
       if (!affected)
         return void 0;