@typescript-deploys/pr-build 5.0.0-pr-51492-2 → 5.0.0-pr-50996-9

package/lib/typingsInstaller.js

@@ -50,7 +50,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20221111`;
+var version = `${versionMajorMinor}.0-insiders.20221123`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -909,15 +909,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;
   }
@@ -1433,52 +1427,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) {
-        log2.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]" : "";
@@ -3198,6 +3146,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   return TypeFlags2;
 })(TypeFlags || {});
 var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
+  ObjectFlags3[ObjectFlags3["None"] = 0] = "None";
   ObjectFlags3[ObjectFlags3["Class"] = 1] = "Class";
   ObjectFlags3[ObjectFlags3["Interface"] = 2] = "Interface";
   ObjectFlags3[ObjectFlags3["Reference"] = 4] = "Reference";
@@ -6219,10 +6168,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}'."),
@@ -11456,12 +11405,10 @@ 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 hasJSFileExtension(fileName) {
   return some(supportedJSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
 }
-function hasTSFileExtension(fileName) {
-  return some(supportedTSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
-}
 var extensionsToRemove = [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".mts" /* Mts */, ".cjs" /* Cjs */, ".cts" /* Cts */, ".ts" /* Ts */, ".js" /* Js */, ".tsx" /* Tsx */, ".jsx" /* Jsx */, ".json" /* Json */];
 function removeFileExtension(path2) {
   for (const ext of extensionsToRemove) {
@@ -25795,15 +25742,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 createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
   if (resultFromCache) {
     resultFromCache.failedLookupLocations.push(...failedLookupLocations);
@@ -26128,38 +26078,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 = [];
@@ -26179,12 +26133,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,
@@ -26209,7 +26171,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);
       }
@@ -26250,7 +26212,7 @@ function realPath(path2, 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) {
@@ -26308,10 +26270,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);
@@ -26319,10 +26280,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) {
@@ -26332,7 +26292,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;
   }
@@ -26345,59 +26305,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;
+      }
+      if (extensions & 8 /* Json */) {
+        candidate = originalCandidate;
+        const result = tryExtension(".json" /* Json */);
+        if (result)
+          return result;
       }
-    case 3 /* TSConfig */:
-    case 2 /* Json */:
-      return tryExtension(".json" /* Json */);
+      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 path2 = tryFile(candidate + ext, onlyRecordFailures, state);
@@ -26491,23 +26424,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) => {
@@ -26521,18 +26441,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) {
@@ -26555,19 +26475,7 @@ function resolvedIfExtensionMatches(extensions, path2) {
   return ext !== void 0 && extensionIsOk(extensions, ext) ? { path: path2, 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);
@@ -26729,7 +26637,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) {
@@ -26820,7 +26728,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) {
@@ -26857,10 +26765,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)));
                     }
@@ -26901,19 +26808,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");
@@ -26921,11 +26840,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)) {
@@ -26934,7 +26855,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) {
@@ -27062,9 +26983,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,
@@ -27091,7 +27013,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 {
@@ -29874,6 +29796,7 @@ var CheckMode = /* @__PURE__ */ ((CheckMode3) => {
   return CheckMode3;
 })(CheckMode || {});
 var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
+  SignatureCheckMode3[SignatureCheckMode3["None"] = 0] = "None";
   SignatureCheckMode3[SignatureCheckMode3["BivariantCallback"] = 1] = "BivariantCallback";
   SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
   SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
@@ -31137,10 +31060,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) {
@@ -31795,7 +31718,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();
@@ -31803,6 +31726,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");
@@ -31841,30 +31765,29 @@ var BuilderState;
     state.allFileNames = void 0;
   }
   BuilderState2.releaseCache = releaseCache;
-  function getFilesAffectedBy(state, programOfThisState, path2, cancellationToken, computeHash, getCanonicalFileName) {
+  function getFilesAffectedBy(state, programOfThisState, path2, cancellationToken, host) {
     var _a2, _b;
     const result = getFilesAffectedByWithOldState(
       state,
       programOfThisState,
       path2,
       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, path2, cancellationToken, computeHash, getCanonicalFileName) {
+  function getFilesAffectedByWithOldState(state, programOfThisState, path2, cancellationToken, host) {
     const sourceFile = programOfThisState.getSourceFileByPath(path2);
     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, path2) {
@@ -31872,7 +31795,7 @@ var BuilderState;
     (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path2);
   }
   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;
@@ -31885,10 +31808,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) {
@@ -32027,7 +31950,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);
     }
@@ -32043,7 +31966,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));
         }
       }
@@ -32056,8 +31979,9 @@ var BuilderState;
 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) {
@@ -32065,7 +31989,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");
   }
@@ -32074,7 +31998,11 @@ 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})`;
   }
 }