typescript 5.0.0-dev.20221115 → 5.0.0-dev.20221117

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.20221115`;
+var version = `${versionMajorMinor}.0-dev.20221117`;
 
 // 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]" : "";
@@ -3712,6 +3660,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";
@@ -6776,10 +6725,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 +15083,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 +21071,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 +32672,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 +32887,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 +32938,7 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
         }
         return resolvedTypeScriptOnly(
           loadNodeModuleFromDirectory(
-            4 /* DtsOnly */,
+            4 /* Declaration */,
             candidate,
             !directoryExists,
             moduleResolutionState
@@ -33005,11 +32959,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 +33479,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 +33534,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 +33572,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 +33613,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 +33671,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 +33681,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 +33693,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 +33706,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 +33780,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 +33840,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 +33857,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 +33891,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 +34053,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 +34144,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 +34181,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 +34224,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 +34256,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 +34271,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 +34412,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 +34442,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 +34469,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 +37422,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 +37430,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;
@@ -38115,6 +38061,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";
@@ -38132,7 +38079,7 @@ var intrinsicTypeKinds = new Map(getEntries({
 function SymbolLinks() {
 }
 function NodeLinks() {
-  this.flags = 0;
+  this.flags = 0 /* None */;
 }
 function getNodeId(node) {
   if (!node.id) {
@@ -38977,7 +38924,7 @@ function createTypeChecker(host) {
   function createSymbol(flags, name, checkFlags) {
     symbolCount++;
     const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
-    symbol.checkFlags = checkFlags || 0;
+    symbol.checkFlags = checkFlags || 0 /* None */;
     return symbol;
   }
   function getExcludedSymbolFlags(flags) {
@@ -41288,7 +41235,7 @@ function createTypeChecker(host) {
   function createOriginType(flags) {
     return new Type7(checker, flags);
   }
-  function createIntrinsicType(kind, intrinsicName, objectFlags = 0) {
+  function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */) {
     const type = createType(kind);
     type.intrinsicName = intrinsicName;
     type.objectFlags = objectFlags;
@@ -48129,7 +48076,7 @@ function createTypeChecker(host) {
   function containsArgumentsReference(declaration) {
     const links = getNodeLinks(declaration);
     if (links.containsArgumentsReference === void 0) {
-      if (links.flags & 8192 /* CaptureArguments */) {
+      if (links.flags & 512 /* CaptureArguments */) {
         links.containsArgumentsReference = true;
       } else {
         links.containsArgumentsReference = traverse(declaration.body);
@@ -52029,7 +51976,7 @@ function createTypeChecker(host) {
     return compareSignaturesRelated(
       source,
       target,
-      ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0,
+      ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0 /* None */,
       false,
       void 0,
       void 0,
@@ -52263,7 +52210,9 @@ function createTypeChecker(host) {
     if (relation === assignableRelation || relation === comparableRelation) {
       if (s & 1 /* Any */)
         return true;
-      if (s & (8 /* Number */ | 256 /* NumberLiteral */) && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || relation === assignableRelation && t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
+      if (s & 8 /* Number */ && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
+        return true;
+      if (s & 256 /* NumberLiteral */ && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */ && source.value === target.value))
         return true;
       if (isUnknownLikeUnionType(target))
         return true;
@@ -55326,7 +55275,7 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
-  function inferTypes(inferences, originalSource, originalTarget, priority = 0, contravariant = false) {
+  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
     let inferencePriority = 2048 /* MaxValue */;
@@ -57768,8 +57717,8 @@ function createTypeChecker(host) {
     }
     const parent = getRootDeclaration(symbol.valueDeclaration).parent;
     const links = getNodeLinks(parent);
-    if (!(links.flags & 8388608 /* AssignmentsMarked */)) {
-      links.flags |= 8388608 /* AssignmentsMarked */;
+    if (!(links.flags & 524288 /* AssignmentsMarked */)) {
+      links.flags |= 524288 /* AssignmentsMarked */;
       if (!hasParentWithAssignmentsMarked(parent)) {
         markNodeAssignments(parent);
       }
@@ -57777,7 +57726,7 @@ function createTypeChecker(host) {
     return symbol.isAssigned || false;
   }
   function hasParentWithAssignmentsMarked(node) {
-    return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 8388608 /* AssignmentsMarked */));
+    return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 524288 /* AssignmentsMarked */));
   }
   function markNodeAssignments(node) {
     if (node.kind === 79 /* Identifier */) {
@@ -57856,11 +57805,11 @@ function createTypeChecker(host) {
         const parent = declaration.parent.parent;
         if (parent.kind === 257 /* VariableDeclaration */ && getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 166 /* Parameter */) {
           const links = getNodeLinks(parent);
-          if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
-            links.flags |= 268435456 /* InCheckIdentifier */;
+          if (!(links.flags & 16777216 /* InCheckIdentifier */)) {
+            links.flags |= 16777216 /* InCheckIdentifier */;
             const parentType = getTypeForBindingElementParent(parent, 0 /* Normal */);
             const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
-            links.flags &= ~268435456 /* InCheckIdentifier */;
+            links.flags &= ~16777216 /* InCheckIdentifier */;
             if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent.kind === 166 /* Parameter */ && isSymbolAssigned(symbol))) {
               const pattern = declaration.parent;
               const narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, void 0, location.flowNode);
@@ -57910,7 +57859,7 @@ function createTypeChecker(host) {
           error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
         }
       }
-      getNodeLinks(container).flags |= 8192 /* CaptureArguments */;
+      getNodeLinks(container).flags |= 512 /* CaptureArguments */;
       return getTypeOfSymbol(symbol);
     }
     if (shouldMarkIdentifierAliasReferenced(node)) {
@@ -57927,8 +57876,8 @@ function createTypeChecker(host) {
         let container = getContainingClass(node);
         while (container !== void 0) {
           if (container === declaration && container.name !== node) {
-            getNodeLinks(declaration).flags |= 16777216 /* ClassWithConstructorReference */;
-            getNodeLinks(node).flags |= 33554432 /* ConstructorReferenceInClass */;
+            getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
+            getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
             break;
           }
           container = getContainingClass(container);
@@ -57938,8 +57887,8 @@ function createTypeChecker(host) {
         while (container.kind !== 308 /* SourceFile */) {
           if (container.parent === declaration) {
             if (isPropertyDeclaration(container) && isStatic(container) || isClassStaticBlockDeclaration(container)) {
-              getNodeLinks(declaration).flags |= 16777216 /* ClassWithConstructorReference */;
-              getNodeLinks(node).flags |= 33554432 /* ConstructorReferenceInClass */;
+              getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
+              getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
             }
             break;
           }
@@ -58053,7 +58002,7 @@ function createTypeChecker(host) {
             const part = getPartOfForStatementContainingNode(node.parent, container);
             if (part) {
               const links = getNodeLinks(part);
-              links.flags |= 131072 /* ContainsCapturedBlockScopeBinding */;
+              links.flags |= 8192 /* ContainsCapturedBlockScopeBinding */;
               const capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
               pushIfUnique(capturedBindings, symbol);
               if (part === container.initializer) {
@@ -58063,19 +58012,19 @@ function createTypeChecker(host) {
           }
         }
         if (capturesBlockScopeBindingInLoopBody) {
-          getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+          getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
         }
       }
       if (isForStatement(container)) {
         const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
         if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
-          getNodeLinks(symbol.valueDeclaration).flags |= 4194304 /* NeedsLoopOutParameter */;
+          getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* NeedsLoopOutParameter */;
         }
       }
-      getNodeLinks(symbol.valueDeclaration).flags |= 524288 /* BlockScopedBindingInLoop */;
+      getNodeLinks(symbol.valueDeclaration).flags |= 32768 /* BlockScopedBindingInLoop */;
     }
     if (isCaptured) {
-      getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* CapturedBlockScopedBinding */;
+      getNodeLinks(symbol.valueDeclaration).flags |= 16384 /* CapturedBlockScopedBinding */;
     }
   }
   function isBindingCapturedByNode(node, decl) {
@@ -58292,23 +58241,23 @@ function createTypeChecker(host) {
       checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
     }
     if (isStatic(container) || isCallExpression2) {
-      nodeCheckFlag = 512 /* SuperStatic */;
+      nodeCheckFlag = 32 /* SuperStatic */;
       if (!isCallExpression2 && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && (isPropertyDeclaration(container) || isClassStaticBlockDeclaration(container))) {
         forEachEnclosingBlockScopeContainer(node.parent, (current) => {
           if (!isSourceFile(current) || isExternalOrCommonJsModule(current)) {
-            getNodeLinks(current).flags |= 134217728 /* ContainsSuperPropertyInStaticInitializer */;
+            getNodeLinks(current).flags |= 8388608 /* ContainsSuperPropertyInStaticInitializer */;
           }
         });
       }
     } else {
-      nodeCheckFlag = 256 /* SuperInstance */;
+      nodeCheckFlag = 16 /* SuperInstance */;
     }
     getNodeLinks(node).flags |= nodeCheckFlag;
     if (container.kind === 171 /* MethodDeclaration */ && inAsyncFunction) {
       if (isSuperProperty(node.parent) && isAssignmentTarget(node.parent)) {
-        getNodeLinks(container).flags |= 4096 /* MethodWithSuperPropertyAssignmentInAsync */;
+        getNodeLinks(container).flags |= 256 /* MethodWithSuperPropertyAssignmentInAsync */;
       } else {
-        getNodeLinks(container).flags |= 2048 /* MethodWithSuperPropertyAccessInAsync */;
+        getNodeLinks(container).flags |= 128 /* MethodWithSuperPropertyAccessInAsync */;
       }
     }
     if (needToCaptureLexicalThis) {
@@ -58336,7 +58285,7 @@ function createTypeChecker(host) {
       error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
       return errorType;
     }
-    return nodeCheckFlag === 512 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
+    return nodeCheckFlag === 32 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
     function isLegalUsageOfSuperExpression(container2) {
       if (!container2) {
         return false;
@@ -59351,9 +59300,9 @@ function createTypeChecker(host) {
         const container = getEnclosingBlockScopeContainer(node.parent.parent);
         const enclosingIterationStatement = getEnclosingIterationStatement(container);
         if (enclosingIterationStatement) {
-          getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
-          getNodeLinks(node).flags |= 524288 /* BlockScopedBindingInLoop */;
-          getNodeLinks(node.parent.parent).flags |= 524288 /* BlockScopedBindingInLoop */;
+          getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+          getNodeLinks(node).flags |= 32768 /* BlockScopedBindingInLoop */;
+          getNodeLinks(node.parent.parent).flags |= 32768 /* BlockScopedBindingInLoop */;
         }
       }
       if (links.resolvedType.flags & 98304 /* Nullable */ || !isTypeAssignableToKind(links.resolvedType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */) && !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
@@ -63340,10 +63289,10 @@ function createTypeChecker(host) {
   }
   function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
     const links = getNodeLinks(node);
-    if (!(links.flags & 1024 /* ContextChecked */)) {
+    if (!(links.flags & 64 /* ContextChecked */)) {
       const contextualSignature = getContextualSignature(node);
-      if (!(links.flags & 1024 /* ContextChecked */)) {
-        links.flags |= 1024 /* ContextChecked */;
+      if (!(links.flags & 64 /* ContextChecked */)) {
+        links.flags |= 64 /* ContextChecked */;
         const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0 /* Call */));
         if (!signature) {
           return;
@@ -65333,13 +65282,13 @@ function createTypeChecker(host) {
   function setNodeLinksForPrivateIdentifierScope(node) {
     if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
       for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
-        getNodeLinks(lexicalScope).flags |= 67108864 /* ContainsClassWithPrivateIdentifiers */;
+        getNodeLinks(lexicalScope).flags |= 4194304 /* ContainsClassWithPrivateIdentifiers */;
       }
       if (isClassExpression(node.parent)) {
         const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
         if (enclosingIterationStatement) {
-          getNodeLinks(node.name).flags |= 524288 /* BlockScopedBindingInLoop */;
-          getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+          getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
+          getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
         }
       }
     }
@@ -66934,7 +66883,7 @@ function createTypeChecker(host) {
   }
   function checkWeakMapSetCollision(node) {
     const enclosingBlockScope = getEnclosingBlockScopeContainer(node);
-    if (getNodeCheckFlags(enclosingBlockScope) & 67108864 /* ContainsClassWithPrivateIdentifiers */) {
+    if (getNodeCheckFlags(enclosingBlockScope) & 4194304 /* ContainsClassWithPrivateIdentifiers */) {
       Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name) && typeof node.name.escapedText === "string", "The target of a WeakMap/WeakSet collision check should be an identifier");
       errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, node.name.escapedText);
     }
@@ -66948,18 +66897,18 @@ function createTypeChecker(host) {
     let hasCollision = false;
     if (isClassExpression(node)) {
       for (const member of node.members) {
-        if (getNodeCheckFlags(member) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+        if (getNodeCheckFlags(member) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
           hasCollision = true;
           break;
         }
       }
     } else if (isFunctionExpression(node)) {
-      if (getNodeCheckFlags(node) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+      if (getNodeCheckFlags(node) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
         hasCollision = true;
       }
     } else {
       const container = getEnclosingBlockScopeContainer(node);
-      if (container && getNodeCheckFlags(container) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+      if (container && getNodeCheckFlags(container) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
         hasCollision = true;
       }
     }
@@ -68844,8 +68793,8 @@ function createTypeChecker(host) {
   }
   function computeEnumMemberValues(node) {
     const nodeLinks2 = getNodeLinks(node);
-    if (!(nodeLinks2.flags & 16384 /* EnumValuesComputed */)) {
-      nodeLinks2.flags |= 16384 /* EnumValuesComputed */;
+    if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
+      nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
       let autoValue = 0;
       for (const member of node.members) {
         const value = computeMemberValue(member, autoValue);
@@ -69121,7 +69070,7 @@ function createTypeChecker(host) {
         }
         const mergedClass = getDeclarationOfKind(symbol, 260 /* ClassDeclaration */);
         if (mergedClass && inSameLexicalScope(node, mergedClass)) {
-          getNodeLinks(node).flags |= 32768 /* LexicalModuleMergesWithClass */;
+          getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
         }
       }
       if (isAmbientExternalModule) {
@@ -70752,8 +70701,8 @@ function createTypeChecker(host) {
           const nodeLinks2 = getNodeLinks(symbol.valueDeclaration);
           if (resolveName(container.parent, symbol.escapedName, 111551 /* Value */, void 0, void 0, false)) {
             links.isDeclarationWithCollidingName = true;
-          } else if (nodeLinks2.flags & 262144 /* CapturedBlockScopedBinding */) {
-            const isDeclaredInLoop = nodeLinks2.flags & 524288 /* BlockScopedBindingInLoop */;
+          } else if (nodeLinks2.flags & 16384 /* CapturedBlockScopedBinding */) {
+            const isDeclaredInLoop = nodeLinks2.flags & 32768 /* BlockScopedBindingInLoop */;
             const inLoopInitializer = isIterationStatement(container, false);
             const inLoopBodyBlock = container.kind === 238 /* Block */ && isIterationStatement(container.parent, false);
             links.isDeclarationWithCollidingName = !isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || !inLoopInitializer && !inLoopBodyBlock);
@@ -74189,10 +74138,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) {
@@ -77728,12 +77677,12 @@ function transformClassFields(context) {
   function visitClassExpressionInNewClassLexicalEnvironment(node, facts) {
     const isDecoratedClassDeclaration = !!(facts & 1 /* ClassWasDecorated */);
     const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
-    const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 16777216 /* ClassWithConstructorReference */;
+    const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */;
     let temp;
     function createClassTempVar() {
       const classCheckFlags = resolver.getNodeCheckFlags(node);
-      const isClassWithConstructorReference2 = classCheckFlags & 16777216 /* ClassWithConstructorReference */;
-      const requiresBlockScopedVar = classCheckFlags & 524288 /* BlockScopedBindingInLoop */;
+      const isClassWithConstructorReference2 = classCheckFlags & 1048576 /* ClassWithConstructorReference */;
+      const requiresBlockScopedVar = classCheckFlags & 32768 /* BlockScopedBindingInLoop */;
       return factory2.createTempVariable(requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration, !!isClassWithConstructorReference2);
     }
     if (facts & 2 /* NeedsClassConstructorReference */) {
@@ -78246,7 +78195,7 @@ function transformClassFields(context) {
   }
   function trySubstituteClassAlias(node) {
     if (enabledSubstitutions & 1 /* ClassAliases */) {
-      if (resolver.getNodeCheckFlags(node) & 33554432 /* ConstructorReferenceInClass */) {
+      if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
         const declaration = resolver.getReferencedValueDeclaration(node);
         if (declaration) {
           const classAlias = classAliases[declaration.id];
@@ -78269,7 +78218,7 @@ function transformClassFields(context) {
       const alreadyTransformed = isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
       if (!alreadyTransformed && !inlinable && shouldHoist) {
         const generatedName = factory2.getGeneratedNameForNode(name);
-        if (resolver.getNodeCheckFlags(name) & 524288 /* BlockScopedBindingInLoop */) {
+        if (resolver.getNodeCheckFlags(name) & 32768 /* BlockScopedBindingInLoop */) {
           addBlockScopedVariable(generatedName);
         } else {
           hoistVariableDeclaration(generatedName);
@@ -78418,7 +78367,7 @@ function transformClassFields(context) {
     const { className } = getPrivateIdentifierEnvironment();
     const prefix = className ? { prefix: "_", node: className, suffix: "_" } : "_";
     const identifier = typeof name === "object" ? factory2.getGeneratedNameForNode(name, 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */, prefix, suffix) : typeof name === "string" ? factory2.createUniqueName(name, 16 /* Optimistic */, prefix, suffix) : factory2.createTempVariable(void 0, true, prefix, suffix);
-    if (resolver.getNodeCheckFlags(node) & 524288 /* BlockScopedBindingInLoop */) {
+    if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
       addBlockScopedVariable(identifier);
     } else {
       hoistVariableDeclaration(identifier);
@@ -79283,7 +79232,7 @@ function transformLegacyDecorators(context) {
     }
   }
   function getClassAliasIfNeeded(node) {
-    if (resolver.getNodeCheckFlags(node) & 16777216 /* ClassWithConstructorReference */) {
+    if (resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */) {
       enableSubstitutionForClassAliases();
       const classAlias = factory2.createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? idText(node.name) : "default");
       classAliases[getOriginalNodeId(node)] = classAlias;
@@ -79317,7 +79266,7 @@ function transformLegacyDecorators(context) {
   }
   function trySubstituteClassAlias(node) {
     if (classAliases) {
-      if (resolver.getNodeCheckFlags(node) & 33554432 /* ConstructorReferenceInClass */) {
+      if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
         const declaration = resolver.getReferencedValueDeclaration(node);
         if (declaration) {
           const classAlias = classAliases[declaration.id];
@@ -79352,7 +79301,7 @@ function transformES2017(context) {
   let capturedSuperProperties;
   let hasSuperElementAccess;
   const substitutedSuperAccessors = [];
-  let contextFlags = 0;
+  let contextFlags = 0 /* None */;
   const previousOnEmitNode = context.onEmitNode;
   const previousOnSubstituteNode = context.onSubstituteNode;
   context.onEmitNode = onEmitNode;
@@ -79679,7 +79628,7 @@ function transformES2017(context) {
     hasSuperElementAccess = false;
     let updated = visitFunctionBody(node.body, visitor, context);
     const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
-    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
+    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
     if (emitSuperHelpers) {
       enableSubstitutionForAsyncMethodsWithSuper();
       if (capturedSuperProperties.size) {
@@ -79690,9 +79639,9 @@ function transformES2017(context) {
         updated = factory2.updateBlock(updated, statements);
       }
       if (hasSuperElementAccess) {
-        if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+        if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
           addEmitHelper(updated, advancedAsyncSuperHelper);
-        } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+        } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
           addEmitHelper(updated, asyncSuperHelper);
         }
       }
@@ -79707,7 +79656,7 @@ function transformES2017(context) {
     const nodeType = original.type;
     const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
     const isArrowFunction2 = node.kind === 216 /* ArrowFunction */;
-    const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192 /* CaptureArguments */) !== 0;
+    const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
     const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
     enclosingFunctionParameterNames = /* @__PURE__ */ new Set();
     for (const parameter of node.parameters) {
@@ -79734,7 +79683,7 @@ function transformES2017(context) {
         )
       );
       insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
-      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */);
+      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
         if (capturedSuperProperties.size) {
@@ -79746,9 +79695,9 @@ function transformES2017(context) {
       const block = factory2.createBlock(statements, true);
       setTextRange(block, node.body);
       if (emitSuperHelpers && hasSuperElementAccess) {
-        if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+        if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
           addEmitHelper(block, advancedAsyncSuperHelper);
-        } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+        } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
           addEmitHelper(block, asyncSuperHelper);
         }
       }
@@ -79808,7 +79757,7 @@ function transformES2017(context) {
   }
   function onEmitNode(hint, node, emitCallback) {
     if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-      const superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* MethodWithSuperPropertyAccessInAsync */ | 4096 /* MethodWithSuperPropertyAssignmentInAsync */);
+      const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
       if (superContainerFlags !== enclosingSuperContainerFlags) {
         const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
         enclosingSuperContainerFlags = superContainerFlags;
@@ -79884,7 +79833,7 @@ function transformES2017(context) {
     return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
   }
   function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-    if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+    if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
       return setTextRange(
         factory2.createPropertyAccessExpression(
           factory2.createCallExpression(
@@ -79909,7 +79858,7 @@ function transformES2017(context) {
   }
 }
 function createSuperAccessVariableStatement(factory2, resolver, node, names) {
-  const hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
+  const hasBinding = (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
   const accessors = [];
   names.forEach((_, key) => {
     const name = unescapeLeadingUnderscores(key);
@@ -80847,7 +80796,7 @@ function transformES2018(context) {
         !!(hierarchyFacts & 1 /* HasLexicalThis */)
       )
     );
-    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */);
+    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
     if (emitSuperHelpers) {
       enableSubstitutionForAsyncMethodsWithSuper();
       const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
@@ -80858,9 +80807,9 @@ function transformES2018(context) {
     insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
     const block = factory2.updateBlock(node.body, statements);
     if (emitSuperHelpers && hasSuperElementAccess) {
-      if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         addEmitHelper(block, advancedAsyncSuperHelper);
-      } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+      } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
         addEmitHelper(block, asyncSuperHelper);
       }
     }
@@ -80970,7 +80919,7 @@ function transformES2018(context) {
   }
   function onEmitNode(hint, node, emitCallback) {
     if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-      const superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* MethodWithSuperPropertyAccessInAsync */ | 4096 /* MethodWithSuperPropertyAssignmentInAsync */);
+      const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
       if (superContainerFlags !== enclosingSuperContainerFlags) {
         const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
         enclosingSuperContainerFlags = superContainerFlags;
@@ -81046,7 +80995,7 @@ function transformES2018(context) {
     return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
   }
   function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-    if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+    if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
       return setTextRange(
         factory2.createPropertyAccessExpression(
           factory2.createCallExpression(
@@ -83402,8 +83351,8 @@ function transformES2015(context) {
   }
   function shouldEmitExplicitInitializerForLetDeclaration(node) {
     const flags = resolver.getNodeCheckFlags(node);
-    const isCapturedInFunction = flags & 262144 /* CapturedBlockScopedBinding */;
-    const isDeclaredInLoop = flags & 524288 /* BlockScopedBindingInLoop */;
+    const isCapturedInFunction = flags & 16384 /* CapturedBlockScopedBinding */;
+    const isDeclaredInLoop = flags & 32768 /* BlockScopedBindingInLoop */;
     const emittedAsTopLevel = (hierarchyFacts & 64 /* TopLevel */) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512 /* IterationStatementBlock */) !== 0;
     const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096 /* ForInOrForOfStatement */) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 /* ForStatement */ | 4096 /* ForInOrForOfStatement */)) === 0);
     return emitExplicitInitializer;
@@ -83764,7 +83713,7 @@ function transformES2015(context) {
     return factory2.inlineExpressions(expressions);
   }
   function shouldConvertPartOfIterationStatement(node) {
-    return (resolver.getNodeCheckFlags(node) & 131072 /* ContainsCapturedBlockScopeBinding */) !== 0;
+    return (resolver.getNodeCheckFlags(node) & 8192 /* ContainsCapturedBlockScopeBinding */) !== 0;
   }
   function shouldConvertInitializerOfForStatement(node) {
     return isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer);
@@ -83779,7 +83728,7 @@ function transformES2015(context) {
     return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
   }
   function shouldConvertBodyOfIterationStatement(node) {
-    return (resolver.getNodeCheckFlags(node) & 65536 /* LoopWithCapturedBlockScopedBinding */) !== 0;
+    return (resolver.getNodeCheckFlags(node) & 4096 /* LoopWithCapturedBlockScopedBinding */) !== 0;
   }
   function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) {
     if (!state.hoistedLocalVariables) {
@@ -84240,10 +84189,10 @@ function transformES2015(context) {
     } else {
       loopParameters.push(factory2.createParameterDeclaration(void 0, void 0, name));
       const checkFlags = resolver.getNodeCheckFlags(decl);
-      if (checkFlags & 4194304 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
+      if (checkFlags & 262144 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
         const outParamName = factory2.createUniqueName("out_" + idText(name));
-        let flags = 0;
-        if (checkFlags & 4194304 /* NeedsLoopOutParameter */) {
+        let flags = 0 /* None */;
+        if (checkFlags & 262144 /* NeedsLoopOutParameter */) {
           flags |= 1 /* Body */;
         }
         if (isForStatement(container)) {
@@ -92160,7 +92109,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();
@@ -92168,7 +92117,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) {
@@ -92314,7 +92263,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)
@@ -92324,22 +92272,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(
@@ -92409,7 +92357,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;
@@ -92422,7 +92370,7 @@ function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransforme
     getSourceFileFromReference: returnUndefined,
     redirectTargetsMap: createMultiMap(),
     getFileIncludeReasons: notImplemented,
-    createHash
+    createHash: maybeBind(host, host.createHash)
   };
   emitFiles(
     notImplementedResolver,
@@ -100479,7 +100427,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();
@@ -100487,6 +100435,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");
@@ -100525,30 +100474,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) {
@@ -100556,7 +100504,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;
@@ -100569,10 +100517,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) {
@@ -100711,7 +100659,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);
     }
@@ -100727,7 +100675,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));
         }
       }
@@ -100769,9 +100717,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;
@@ -100815,7 +100763,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();
         }
@@ -100875,10 +100823,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;
@@ -100890,7 +100839,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) {
@@ -100932,7 +100882,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;
@@ -100948,8 +100898,6 @@ function getNextAffectedFile(state, cancellationToken, computeHash, getCanonical
             state,
             affectedFile,
             cancellationToken,
-            computeHash,
-            getCanonicalFileName,
             host
           );
           return affectedFile;
@@ -100977,8 +100925,7 @@ function getNextAffectedFile(state, cancellationToken, computeHash, getCanonical
       program,
       nextKey.value,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName
+      host
     );
     state.currentChangedFilePath = nextKey.value;
     state.affectedFilesIndex = 0;
@@ -101030,7 +100977,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);
@@ -101039,8 +100986,7 @@ function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken
       Debug.checkDefined(state.program),
       affectedFile,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName
+      host
     );
     return;
   }
@@ -101050,12 +100996,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);
@@ -101066,8 +101010,7 @@ function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCa
         program,
         sourceFile,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName,
+        host,
         !host.disableUseFileVersionAsSignature
       );
       if (getEmitDeclarations(state.compilerOptions)) {
@@ -101089,7 +101032,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;
@@ -101097,14 +101040,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;
@@ -101118,9 +101059,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));
@@ -101130,7 +101071,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(
@@ -101140,28 +101081,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
     )
   );
@@ -101170,8 +101107,6 @@ function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndEx
       state,
       referencingFilePath,
       cancellationToken,
-      computeHash,
-      getCanonicalFileName,
       host
     )
   );
@@ -101200,9 +101135,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 = [];
@@ -101421,8 +101357,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) {
@@ -101430,7 +101367,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");
   }
@@ -101439,11 +101376,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();
@@ -101452,10 +101394,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;
@@ -101489,7 +101429,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) {
@@ -101563,10 +101503,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))
@@ -101610,7 +101550,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;
@@ -101666,7 +101606,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;