typescript 5.0.0-dev.20221115 → 5.0.0-dev.20221116

package/lib/tsserver.js

@@ -2257,6 +2257,7 @@ var ts = (() => {
     supportedLocaleDirectories: () => supportedLocaleDirectories,
     supportedTSExtensions: () => supportedTSExtensions,
     supportedTSExtensionsFlat: () => supportedTSExtensionsFlat,
+    supportedTSImplementationExtensions: () => supportedTSImplementationExtensions,
     suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia,
     suppressLeadingTrivia: () => suppressLeadingTrivia,
     suppressTrailingTrivia: () => suppressTrailingTrivia,
@@ -2647,7 +2648,7 @@ var ts = (() => {
 
   // src/compiler/corePublic.ts
   var versionMajorMinor = "5.0";
-  var version = `${versionMajorMinor}.0-dev.20221115`;
+  var version = `${versionMajorMinor}.0-dev.20221116`;
   var Comparison = /* @__PURE__ */ ((Comparison3) => {
     Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
     Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4382,15 +4383,9 @@ var ts = (() => {
   })(LogLevel || {});
   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;
     }
@@ -4906,52 +4901,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]" : "";
@@ -10642,10 +10591,10 @@ ${lanes.join("\n")}
     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}'."),
@@ -19582,6 +19531,7 @@ ${lanes.join("\n")}
   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) {
@@ -25634,7 +25584,7 @@ ${lanes.join("\n")}
             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 = {
@@ -37420,15 +37370,18 @@ ${lanes.join("\n")}
       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;
@@ -37632,7 +37585,8 @@ ${lanes.join("\n")}
       features,
       conditions,
       requestContainingDirectory: containingDirectory,
-      reportDiagnostic: (diag2) => void diagnostics.push(diag2)
+      reportDiagnostic: (diag2) => void diagnostics.push(diag2),
+      isConfigLookup: false
     };
     let resolved = primaryLookup();
     let primary = true;
@@ -37682,7 +37636,7 @@ ${lanes.join("\n")}
           }
           return resolvedTypeScriptOnly(
             loadNodeModuleFromDirectory(
-              4 /* DtsOnly */,
+              4 /* Declaration */,
               candidate,
               !directoryExists,
               moduleResolutionState
@@ -37703,11 +37657,11 @@ ${lanes.join("\n")}
         }
         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 {
@@ -38233,38 +38187,42 @@ ${lanes.join("\n")}
       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 = [];
@@ -38284,12 +38242,20 @@ ${lanes.join("\n")}
       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,
@@ -38314,7 +38280,7 @@ ${lanes.join("\n")}
         }
         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);
         }
@@ -38355,7 +38321,7 @@ ${lanes.join("\n")}
   }
   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) {
@@ -38413,10 +38379,9 @@ ${lanes.join("\n")}
     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);
@@ -38424,10 +38389,9 @@ ${lanes.join("\n")}
         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) {
@@ -38437,7 +38401,7 @@ ${lanes.join("\n")}
     }
   }
   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;
     }
@@ -38450,59 +38414,32 @@ ${lanes.join("\n")}
         onlyRecordFailures = !directoryProbablyExists(directory, state.host);
       }
     }
-    switch (extensions) {
-      case 4 /* DtsOnly */:
-        switch (originalExtension) {
-          case ".mjs" /* Mjs */:
-          case ".mts" /* Mts */:
-          case ".d.mts" /* Dmts */:
-            return tryExtension(".d.mts" /* Dmts */);
-          case ".cjs" /* Cjs */:
-          case ".cts" /* Cts */:
-          case ".d.cts" /* Dcts */:
-            return tryExtension(".d.cts" /* Dcts */);
-          case ".json" /* Json */:
-            candidate += ".json" /* Json */;
-            return tryExtension(".d.ts" /* Dts */);
-          default:
-            return tryExtension(".d.ts" /* Dts */);
-        }
-      case 0 /* TypeScript */:
-      case 5 /* TsOnly */:
-        const useDts = extensions === 0 /* TypeScript */;
-        switch (originalExtension) {
-          case ".mjs" /* Mjs */:
-          case ".mts" /* Mts */:
-          case ".d.mts" /* Dmts */:
-            return tryExtension(".mts" /* Mts */) || (useDts ? tryExtension(".d.mts" /* Dmts */) : void 0);
-          case ".cjs" /* Cjs */:
-          case ".cts" /* Cts */:
-          case ".d.cts" /* Dcts */:
-            return tryExtension(".cts" /* Cts */) || (useDts ? tryExtension(".d.cts" /* Dcts */) : void 0);
-          case ".json" /* Json */:
-            candidate += ".json" /* Json */;
-            return useDts ? tryExtension(".d.ts" /* Dts */) : void 0;
-          default:
-            return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || (useDts ? tryExtension(".d.ts" /* Dts */) : void 0);
-        }
-      case 1 /* JavaScript */:
-        switch (originalExtension) {
-          case ".mjs" /* Mjs */:
-          case ".mts" /* Mts */:
-          case ".d.mts" /* Dmts */:
-            return tryExtension(".mjs" /* Mjs */);
-          case ".cjs" /* Cjs */:
-          case ".cts" /* Cts */:
-          case ".d.cts" /* Dcts */:
-            return tryExtension(".cjs" /* Cjs */);
-          case ".json" /* Json */:
-            return tryExtension(".json" /* Json */);
-          default:
-            return tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */);
+    switch (originalExtension) {
+      case ".mjs" /* Mjs */:
+      case ".mts" /* Mts */:
+      case ".d.mts" /* Dmts */:
+        return extensions & 1 /* TypeScript */ && tryExtension(".mts" /* Mts */) || extensions & 4 /* Declaration */ && tryExtension(".d.mts" /* Dmts */) || extensions & 2 /* JavaScript */ && tryExtension(".mjs" /* Mjs */) || void 0;
+      case ".cjs" /* Cjs */:
+      case ".cts" /* Cts */:
+      case ".d.cts" /* Dcts */:
+        return extensions & 1 /* TypeScript */ && tryExtension(".cts" /* Cts */) || extensions & 4 /* Declaration */ && tryExtension(".d.cts" /* Dcts */) || extensions & 2 /* JavaScript */ && tryExtension(".cjs" /* Cjs */) || void 0;
+      case ".json" /* Json */:
+        const originalCandidate = candidate;
+        if (extensions & 4 /* Declaration */) {
+          candidate += ".json" /* Json */;
+          const result = tryExtension(".d.ts" /* Dts */);
+          if (result)
+            return result;
+        }
+        if (extensions & 8 /* Json */) {
+          candidate = originalCandidate;
+          const result = tryExtension(".json" /* Json */);
+          if (result)
+            return result;
         }
-      case 3 /* TSConfig */:
-      case 2 /* Json */:
-        return tryExtension(".json" /* Json */);
+        return void 0;
+      default:
+        return extensions & 1 /* TypeScript */ && (tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */)) || extensions & 4 /* Declaration */ && tryExtension(".d.ts" /* Dts */) || extensions & 2 /* JavaScript */ && (tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */)) || state.isConfigLookup && tryExtension(".json" /* Json */) || void 0;
     }
     function tryExtension(ext) {
       const path = tryFile(candidate + ext, onlyRecordFailures, state);
@@ -38545,7 +38482,7 @@ ${lanes.join("\n")}
       return packageJsonInfo.contents.resolvedEntrypoints;
     }
     let entrypoints;
-    const extensions = resolveJs ? 1 /* JavaScript */ : 0 /* TypeScript */;
+    const extensions = 1 /* TypeScript */ | 4 /* Declaration */ | (resolveJs ? 2 /* JavaScript */ : 0);
     const features = getDefaultNodeResolutionFeatures(options);
     const requireState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options);
     requireState.conditions = ["node", "require", "types"];
@@ -38633,7 +38570,8 @@ ${lanes.join("\n")}
       features: 0 /* None */,
       conditions: emptyArray,
       requestContainingDirectory: void 0,
-      reportDiagnostic: noop
+      reportDiagnostic: noop,
+      isConfigLookup: false
     };
   }
   function getPackageScopeForPath(fileName, state) {
@@ -38692,23 +38630,10 @@ ${lanes.join("\n")}
   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) => {
@@ -38722,18 +38647,18 @@ ${lanes.join("\n")}
           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) {
@@ -38756,19 +38681,7 @@ ${lanes.join("\n")}
     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);
@@ -38930,7 +38843,7 @@ ${lanes.join("\n")}
             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) {
@@ -39021,7 +38934,7 @@ ${lanes.join("\n")}
       }
       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) {
@@ -39058,10 +38971,9 @@ ${lanes.join("\n")}
                   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)));
                       }
@@ -39102,19 +39014,31 @@ ${lanes.join("\n")}
     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");
@@ -39122,11 +39046,13 @@ ${lanes.join("\n")}
     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)) {
@@ -39135,7 +39061,7 @@ ${lanes.join("\n")}
         }
         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) {
@@ -39276,9 +39202,10 @@ ${lanes.join("\n")}
       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,
@@ -39305,7 +39232,7 @@ ${lanes.join("\n")}
         if (resolved2) {
           return resolved2;
         }
-        if (extensions === 0 /* TypeScript */) {
+        if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
           return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
         }
       } else {
@@ -39332,9 +39259,10 @@ ${lanes.join("\n")}
       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,
@@ -42333,6 +42261,7 @@ ${lanes.join("\n")}
     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);
@@ -42340,60 +42269,77 @@ ${lanes.join("\n")}
       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;
@@ -79028,10 +78974,10 @@ ${lanes.join("\n")}
         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) {
@@ -97175,7 +97121,7 @@ ${lanes.join("\n")}
           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();
@@ -97183,7 +97129,7 @@ ${lanes.join("\n")}
       const text = writer.getText();
       writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos, diagnostics: transform2.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) {
@@ -97329,7 +97275,6 @@ ${lanes.join("\n")}
     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)
@@ -97339,22 +97284,22 @@ ${lanes.join("\n")}
     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(
@@ -97424,7 +97369,7 @@ ${lanes.join("\n")}
       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;
@@ -97437,7 +97382,7 @@ ${lanes.join("\n")}
       getSourceFileFromReference: returnUndefined,
       redirectTargetsMap: createMultiMap(),
       getFileIncludeReasons: notImplemented,
-      createHash
+      createHash: maybeBind(host, host.createHash)
     };
     emitFiles(
       notImplementedResolver,
@@ -105552,7 +105497,7 @@ ${lanes.join("\n")}
       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();
@@ -105560,6 +105505,7 @@ ${lanes.join("\n")}
       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");
@@ -105598,30 +105544,29 @@ ${lanes.join("\n")}
       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) {
@@ -105629,7 +105574,7 @@ ${lanes.join("\n")}
       (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;
@@ -105642,10 +105587,10 @@ ${lanes.join("\n")}
           (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) {
@@ -105784,7 +105729,7 @@ ${lanes.join("\n")}
       }
       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);
       }
@@ -105800,7 +105745,7 @@ ${lanes.join("\n")}
         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));
           }
         }
@@ -105854,9 +105799,9 @@ ${lanes.join("\n")}
   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;
@@ -105900,7 +105845,7 @@ ${lanes.join("\n")}
           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();
           }
@@ -105960,10 +105905,11 @@ ${lanes.join("\n")}
   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;
@@ -105975,7 +105921,8 @@ ${lanes.join("\n")}
       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) {
@@ -106017,7 +105964,7 @@ ${lanes.join("\n")}
   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;
@@ -106033,8 +105980,6 @@ ${lanes.join("\n")}
               state,
               affectedFile,
               cancellationToken,
-              computeHash,
-              getCanonicalFileName,
               host
             );
             return affectedFile;
@@ -106062,8 +106007,7 @@ ${lanes.join("\n")}
         program,
         nextKey.value,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName
+        host
       );
       state.currentChangedFilePath = nextKey.value;
       state.affectedFilesIndex = 0;
@@ -106115,7 +106059,7 @@ ${lanes.join("\n")}
       );
     }
   }
-  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);
@@ -106124,8 +106068,7 @@ ${lanes.join("\n")}
         Debug.checkDefined(state.program),
         affectedFile,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName
+        host
       );
       return;
     }
@@ -106135,12 +106078,10 @@ ${lanes.join("\n")}
       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);
@@ -106151,8 +106092,7 @@ ${lanes.join("\n")}
           program,
           sourceFile,
           cancellationToken,
-          computeHash,
-          getCanonicalFileName,
+          host,
           !host.disableUseFileVersionAsSignature
         );
         if (getEmitDeclarations(state.compilerOptions)) {
@@ -106174,7 +106114,7 @@ ${lanes.join("\n")}
     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;
@@ -106182,14 +106122,12 @@ ${lanes.join("\n")}
       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;
@@ -106203,9 +106141,9 @@ ${lanes.join("\n")}
         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));
@@ -106215,7 +106153,7 @@ ${lanes.join("\n")}
     }
     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(
@@ -106225,28 +106163,24 @@ ${lanes.join("\n")}
           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
       )
     );
@@ -106255,8 +106189,6 @@ ${lanes.join("\n")}
         state,
         referencingFilePath,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName,
         host
       )
     );
@@ -106285,9 +106217,10 @@ ${lanes.join("\n")}
   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 = [];
@@ -106511,8 +106444,9 @@ ${lanes.join("\n")}
   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) {
@@ -106520,7 +106454,7 @@ ${lanes.join("\n")}
         (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");
     }
@@ -106529,11 +106463,16 @@ ${lanes.join("\n")}
         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();
@@ -106542,10 +106481,8 @@ ${lanes.join("\n")}
       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;
@@ -106579,7 +106516,7 @@ ${lanes.join("\n")}
     }
     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) {
@@ -106653,10 +106590,10 @@ ${lanes.join("\n")}
               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))
@@ -106700,7 +106637,7 @@ ${lanes.join("\n")}
           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;
@@ -106756,7 +106693,7 @@ ${lanes.join("\n")}
     }
     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;
@@ -113591,6 +113528,7 @@ ${lanes.join("\n")}
     supportedLocaleDirectories: () => supportedLocaleDirectories,
     supportedTSExtensions: () => supportedTSExtensions,
     supportedTSExtensionsFlat: () => supportedTSExtensionsFlat,
+    supportedTSImplementationExtensions: () => supportedTSImplementationExtensions,
     suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia,
     suppressLeadingTrivia: () => suppressLeadingTrivia,
     suppressTrailingTrivia: () => suppressTrailingTrivia,
@@ -121568,6 +121506,7 @@ ${lanes.join("\n")}
         trace: maybeBind(host, host.trace),
         resolveModuleNames: maybeBind(host, host.resolveModuleNames),
         getModuleResolutionCache: maybeBind(host, host.getModuleResolutionCache),
+        createHash: maybeBind(host, host.createHash),
         resolveTypeReferenceDirectives: maybeBind(host, host.resolveTypeReferenceDirectives),
         useSourceOfProjectReferenceRedirect: maybeBind(host, host.useSourceOfProjectReferenceRedirect),
         getParsedCommandLine
@@ -150268,6 +150207,57 @@ ${options.prefix}` : "\n" : options.prefix
     }
   })(SmartIndenter || (SmartIndenter = {}));
 
+  // src/deprecatedCompat/deprecate.ts
+  var enableDeprecationWarnings = true;
+  var typeScriptVersion2;
+  function getTypeScriptVersion() {
+    return typeScriptVersion2 != null ? typeScriptVersion2 : typeScriptVersion2 = new Version(version);
+  }
+  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 (enableDeprecationWarnings && !hasWrittenDeprecation) {
+        Debug.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;
+  }
+  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 : Debug.getFunctionName(func), options);
+    return wrapFunction(deprecation, func);
+  }
+
   // src/deprecatedCompat/deprecations.ts
   function createOverload(name, overloads, binder2, deprecations) {
     Object.defineProperty(call, "name", { ...Object.getOwnPropertyDescriptor(call, "name"), value: name });
@@ -150275,7 +150265,7 @@ ${options.prefix}` : "\n" : options.prefix
       for (const key of Object.keys(deprecations)) {
         const index = +key;
         if (!isNaN(index) && hasProperty(overloads, `${index}`)) {
-          overloads[index] = Debug.deprecate(overloads[index], { ...deprecations[index], name });
+          overloads[index] = deprecate(overloads[index], { ...deprecations[index], name });
         }
       }
     }
@@ -150315,336 +150305,336 @@ ${options.prefix}` : "\n" : options.prefix
 
   // src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts
   var factoryDeprecation = { since: "4.0", warnAfter: "4.1", message: "Use the appropriate method on 'ts.factory' or the 'factory' supplied by your transformation context instead." };
-  var createNodeArray = Debug.deprecate(factory.createNodeArray, factoryDeprecation);
-  var createNumericLiteral = Debug.deprecate(factory.createNumericLiteral, factoryDeprecation);
-  var createBigIntLiteral = Debug.deprecate(factory.createBigIntLiteral, factoryDeprecation);
-  var createStringLiteral = Debug.deprecate(factory.createStringLiteral, factoryDeprecation);
-  var createStringLiteralFromNode = Debug.deprecate(factory.createStringLiteralFromNode, factoryDeprecation);
-  var createRegularExpressionLiteral = Debug.deprecate(factory.createRegularExpressionLiteral, factoryDeprecation);
-  var createLoopVariable = Debug.deprecate(factory.createLoopVariable, factoryDeprecation);
-  var createUniqueName = Debug.deprecate(factory.createUniqueName, factoryDeprecation);
-  var createPrivateIdentifier = Debug.deprecate(factory.createPrivateIdentifier, factoryDeprecation);
-  var createSuper = Debug.deprecate(factory.createSuper, factoryDeprecation);
-  var createThis = Debug.deprecate(factory.createThis, factoryDeprecation);
-  var createNull = Debug.deprecate(factory.createNull, factoryDeprecation);
-  var createTrue = Debug.deprecate(factory.createTrue, factoryDeprecation);
-  var createFalse = Debug.deprecate(factory.createFalse, factoryDeprecation);
-  var createModifier = Debug.deprecate(factory.createModifier, factoryDeprecation);
-  var createModifiersFromModifierFlags = Debug.deprecate(factory.createModifiersFromModifierFlags, factoryDeprecation);
-  var createQualifiedName = Debug.deprecate(factory.createQualifiedName, factoryDeprecation);
-  var updateQualifiedName = Debug.deprecate(factory.updateQualifiedName, factoryDeprecation);
-  var createComputedPropertyName = Debug.deprecate(factory.createComputedPropertyName, factoryDeprecation);
-  var updateComputedPropertyName = Debug.deprecate(factory.updateComputedPropertyName, factoryDeprecation);
-  var createTypeParameterDeclaration = Debug.deprecate(factory.createTypeParameterDeclaration, factoryDeprecation);
-  var updateTypeParameterDeclaration = Debug.deprecate(factory.updateTypeParameterDeclaration, factoryDeprecation);
-  var createParameter = Debug.deprecate(factory.createParameterDeclaration, factoryDeprecation);
-  var updateParameter = Debug.deprecate(factory.updateParameterDeclaration, factoryDeprecation);
-  var createDecorator = Debug.deprecate(factory.createDecorator, factoryDeprecation);
-  var updateDecorator = Debug.deprecate(factory.updateDecorator, factoryDeprecation);
-  var createProperty = Debug.deprecate(factory.createPropertyDeclaration, factoryDeprecation);
-  var updateProperty = Debug.deprecate(factory.updatePropertyDeclaration, factoryDeprecation);
-  var createMethod = Debug.deprecate(factory.createMethodDeclaration, factoryDeprecation);
-  var updateMethod = Debug.deprecate(factory.updateMethodDeclaration, factoryDeprecation);
-  var createConstructor = Debug.deprecate(factory.createConstructorDeclaration, factoryDeprecation);
-  var updateConstructor = Debug.deprecate(factory.updateConstructorDeclaration, factoryDeprecation);
-  var createGetAccessor = Debug.deprecate(factory.createGetAccessorDeclaration, factoryDeprecation);
-  var updateGetAccessor = Debug.deprecate(factory.updateGetAccessorDeclaration, factoryDeprecation);
-  var createSetAccessor = Debug.deprecate(factory.createSetAccessorDeclaration, factoryDeprecation);
-  var updateSetAccessor = Debug.deprecate(factory.updateSetAccessorDeclaration, factoryDeprecation);
-  var createCallSignature = Debug.deprecate(factory.createCallSignature, factoryDeprecation);
-  var updateCallSignature = Debug.deprecate(factory.updateCallSignature, factoryDeprecation);
-  var createConstructSignature = Debug.deprecate(factory.createConstructSignature, factoryDeprecation);
-  var updateConstructSignature = Debug.deprecate(factory.updateConstructSignature, factoryDeprecation);
-  var updateIndexSignature = Debug.deprecate(factory.updateIndexSignature, factoryDeprecation);
-  var createKeywordTypeNode = Debug.deprecate(factory.createKeywordTypeNode, factoryDeprecation);
-  var createTypePredicateNodeWithModifier = Debug.deprecate(factory.createTypePredicateNode, factoryDeprecation);
-  var updateTypePredicateNodeWithModifier = Debug.deprecate(factory.updateTypePredicateNode, factoryDeprecation);
-  var createTypeReferenceNode = Debug.deprecate(factory.createTypeReferenceNode, factoryDeprecation);
-  var updateTypeReferenceNode = Debug.deprecate(factory.updateTypeReferenceNode, factoryDeprecation);
-  var createFunctionTypeNode = Debug.deprecate(factory.createFunctionTypeNode, factoryDeprecation);
-  var updateFunctionTypeNode = Debug.deprecate(factory.updateFunctionTypeNode, factoryDeprecation);
-  var createConstructorTypeNode = Debug.deprecate((typeParameters, parameters, type) => {
+  var createNodeArray = deprecate(factory.createNodeArray, factoryDeprecation);
+  var createNumericLiteral = deprecate(factory.createNumericLiteral, factoryDeprecation);
+  var createBigIntLiteral = deprecate(factory.createBigIntLiteral, factoryDeprecation);
+  var createStringLiteral = deprecate(factory.createStringLiteral, factoryDeprecation);
+  var createStringLiteralFromNode = deprecate(factory.createStringLiteralFromNode, factoryDeprecation);
+  var createRegularExpressionLiteral = deprecate(factory.createRegularExpressionLiteral, factoryDeprecation);
+  var createLoopVariable = deprecate(factory.createLoopVariable, factoryDeprecation);
+  var createUniqueName = deprecate(factory.createUniqueName, factoryDeprecation);
+  var createPrivateIdentifier = deprecate(factory.createPrivateIdentifier, factoryDeprecation);
+  var createSuper = deprecate(factory.createSuper, factoryDeprecation);
+  var createThis = deprecate(factory.createThis, factoryDeprecation);
+  var createNull = deprecate(factory.createNull, factoryDeprecation);
+  var createTrue = deprecate(factory.createTrue, factoryDeprecation);
+  var createFalse = deprecate(factory.createFalse, factoryDeprecation);
+  var createModifier = deprecate(factory.createModifier, factoryDeprecation);
+  var createModifiersFromModifierFlags = deprecate(factory.createModifiersFromModifierFlags, factoryDeprecation);
+  var createQualifiedName = deprecate(factory.createQualifiedName, factoryDeprecation);
+  var updateQualifiedName = deprecate(factory.updateQualifiedName, factoryDeprecation);
+  var createComputedPropertyName = deprecate(factory.createComputedPropertyName, factoryDeprecation);
+  var updateComputedPropertyName = deprecate(factory.updateComputedPropertyName, factoryDeprecation);
+  var createTypeParameterDeclaration = deprecate(factory.createTypeParameterDeclaration, factoryDeprecation);
+  var updateTypeParameterDeclaration = deprecate(factory.updateTypeParameterDeclaration, factoryDeprecation);
+  var createParameter = deprecate(factory.createParameterDeclaration, factoryDeprecation);
+  var updateParameter = deprecate(factory.updateParameterDeclaration, factoryDeprecation);
+  var createDecorator = deprecate(factory.createDecorator, factoryDeprecation);
+  var updateDecorator = deprecate(factory.updateDecorator, factoryDeprecation);
+  var createProperty = deprecate(factory.createPropertyDeclaration, factoryDeprecation);
+  var updateProperty = deprecate(factory.updatePropertyDeclaration, factoryDeprecation);
+  var createMethod = deprecate(factory.createMethodDeclaration, factoryDeprecation);
+  var updateMethod = deprecate(factory.updateMethodDeclaration, factoryDeprecation);
+  var createConstructor = deprecate(factory.createConstructorDeclaration, factoryDeprecation);
+  var updateConstructor = deprecate(factory.updateConstructorDeclaration, factoryDeprecation);
+  var createGetAccessor = deprecate(factory.createGetAccessorDeclaration, factoryDeprecation);
+  var updateGetAccessor = deprecate(factory.updateGetAccessorDeclaration, factoryDeprecation);
+  var createSetAccessor = deprecate(factory.createSetAccessorDeclaration, factoryDeprecation);
+  var updateSetAccessor = deprecate(factory.updateSetAccessorDeclaration, factoryDeprecation);
+  var createCallSignature = deprecate(factory.createCallSignature, factoryDeprecation);
+  var updateCallSignature = deprecate(factory.updateCallSignature, factoryDeprecation);
+  var createConstructSignature = deprecate(factory.createConstructSignature, factoryDeprecation);
+  var updateConstructSignature = deprecate(factory.updateConstructSignature, factoryDeprecation);
+  var updateIndexSignature = deprecate(factory.updateIndexSignature, factoryDeprecation);
+  var createKeywordTypeNode = deprecate(factory.createKeywordTypeNode, factoryDeprecation);
+  var createTypePredicateNodeWithModifier = deprecate(factory.createTypePredicateNode, factoryDeprecation);
+  var updateTypePredicateNodeWithModifier = deprecate(factory.updateTypePredicateNode, factoryDeprecation);
+  var createTypeReferenceNode = deprecate(factory.createTypeReferenceNode, factoryDeprecation);
+  var updateTypeReferenceNode = deprecate(factory.updateTypeReferenceNode, factoryDeprecation);
+  var createFunctionTypeNode = deprecate(factory.createFunctionTypeNode, factoryDeprecation);
+  var updateFunctionTypeNode = deprecate(factory.updateFunctionTypeNode, factoryDeprecation);
+  var createConstructorTypeNode = deprecate((typeParameters, parameters, type) => {
     return factory.createConstructorTypeNode(void 0, typeParameters, parameters, type);
   }, factoryDeprecation);
-  var updateConstructorTypeNode = Debug.deprecate((node, typeParameters, parameters, type) => {
+  var updateConstructorTypeNode = deprecate((node, typeParameters, parameters, type) => {
     return factory.updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type);
   }, factoryDeprecation);
-  var createTypeQueryNode = Debug.deprecate(factory.createTypeQueryNode, factoryDeprecation);
-  var updateTypeQueryNode = Debug.deprecate(factory.updateTypeQueryNode, factoryDeprecation);
-  var createTypeLiteralNode = Debug.deprecate(factory.createTypeLiteralNode, factoryDeprecation);
-  var updateTypeLiteralNode = Debug.deprecate(factory.updateTypeLiteralNode, factoryDeprecation);
-  var createArrayTypeNode = Debug.deprecate(factory.createArrayTypeNode, factoryDeprecation);
-  var updateArrayTypeNode = Debug.deprecate(factory.updateArrayTypeNode, factoryDeprecation);
-  var createTupleTypeNode = Debug.deprecate(factory.createTupleTypeNode, factoryDeprecation);
-  var updateTupleTypeNode = Debug.deprecate(factory.updateTupleTypeNode, factoryDeprecation);
-  var createOptionalTypeNode = Debug.deprecate(factory.createOptionalTypeNode, factoryDeprecation);
-  var updateOptionalTypeNode = Debug.deprecate(factory.updateOptionalTypeNode, factoryDeprecation);
-  var createRestTypeNode = Debug.deprecate(factory.createRestTypeNode, factoryDeprecation);
-  var updateRestTypeNode = Debug.deprecate(factory.updateRestTypeNode, factoryDeprecation);
-  var createUnionTypeNode = Debug.deprecate(factory.createUnionTypeNode, factoryDeprecation);
-  var updateUnionTypeNode = Debug.deprecate(factory.updateUnionTypeNode, factoryDeprecation);
-  var createIntersectionTypeNode = Debug.deprecate(factory.createIntersectionTypeNode, factoryDeprecation);
-  var updateIntersectionTypeNode = Debug.deprecate(factory.updateIntersectionTypeNode, factoryDeprecation);
-  var createConditionalTypeNode = Debug.deprecate(factory.createConditionalTypeNode, factoryDeprecation);
-  var updateConditionalTypeNode = Debug.deprecate(factory.updateConditionalTypeNode, factoryDeprecation);
-  var createInferTypeNode = Debug.deprecate(factory.createInferTypeNode, factoryDeprecation);
-  var updateInferTypeNode = Debug.deprecate(factory.updateInferTypeNode, factoryDeprecation);
-  var createImportTypeNode = Debug.deprecate(factory.createImportTypeNode, factoryDeprecation);
-  var updateImportTypeNode = Debug.deprecate(factory.updateImportTypeNode, factoryDeprecation);
-  var createParenthesizedType = Debug.deprecate(factory.createParenthesizedType, factoryDeprecation);
-  var updateParenthesizedType = Debug.deprecate(factory.updateParenthesizedType, factoryDeprecation);
-  var createThisTypeNode = Debug.deprecate(factory.createThisTypeNode, factoryDeprecation);
-  var updateTypeOperatorNode = Debug.deprecate(factory.updateTypeOperatorNode, factoryDeprecation);
-  var createIndexedAccessTypeNode = Debug.deprecate(factory.createIndexedAccessTypeNode, factoryDeprecation);
-  var updateIndexedAccessTypeNode = Debug.deprecate(factory.updateIndexedAccessTypeNode, factoryDeprecation);
-  var createMappedTypeNode = Debug.deprecate(factory.createMappedTypeNode, factoryDeprecation);
-  var updateMappedTypeNode = Debug.deprecate(factory.updateMappedTypeNode, factoryDeprecation);
-  var createLiteralTypeNode = Debug.deprecate(factory.createLiteralTypeNode, factoryDeprecation);
-  var updateLiteralTypeNode = Debug.deprecate(factory.updateLiteralTypeNode, factoryDeprecation);
-  var createObjectBindingPattern = Debug.deprecate(factory.createObjectBindingPattern, factoryDeprecation);
-  var updateObjectBindingPattern = Debug.deprecate(factory.updateObjectBindingPattern, factoryDeprecation);
-  var createArrayBindingPattern = Debug.deprecate(factory.createArrayBindingPattern, factoryDeprecation);
-  var updateArrayBindingPattern = Debug.deprecate(factory.updateArrayBindingPattern, factoryDeprecation);
-  var createBindingElement = Debug.deprecate(factory.createBindingElement, factoryDeprecation);
-  var updateBindingElement = Debug.deprecate(factory.updateBindingElement, factoryDeprecation);
-  var createArrayLiteral = Debug.deprecate(factory.createArrayLiteralExpression, factoryDeprecation);
-  var updateArrayLiteral = Debug.deprecate(factory.updateArrayLiteralExpression, factoryDeprecation);
-  var createObjectLiteral = Debug.deprecate(factory.createObjectLiteralExpression, factoryDeprecation);
-  var updateObjectLiteral = Debug.deprecate(factory.updateObjectLiteralExpression, factoryDeprecation);
-  var createPropertyAccess = Debug.deprecate(factory.createPropertyAccessExpression, factoryDeprecation);
-  var updatePropertyAccess = Debug.deprecate(factory.updatePropertyAccessExpression, factoryDeprecation);
-  var createPropertyAccessChain = Debug.deprecate(factory.createPropertyAccessChain, factoryDeprecation);
-  var updatePropertyAccessChain = Debug.deprecate(factory.updatePropertyAccessChain, factoryDeprecation);
-  var createElementAccess = Debug.deprecate(factory.createElementAccessExpression, factoryDeprecation);
-  var updateElementAccess = Debug.deprecate(factory.updateElementAccessExpression, factoryDeprecation);
-  var createElementAccessChain = Debug.deprecate(factory.createElementAccessChain, factoryDeprecation);
-  var updateElementAccessChain = Debug.deprecate(factory.updateElementAccessChain, factoryDeprecation);
-  var createCall = Debug.deprecate(factory.createCallExpression, factoryDeprecation);
-  var updateCall = Debug.deprecate(factory.updateCallExpression, factoryDeprecation);
-  var createCallChain = Debug.deprecate(factory.createCallChain, factoryDeprecation);
-  var updateCallChain = Debug.deprecate(factory.updateCallChain, factoryDeprecation);
-  var createNew = Debug.deprecate(factory.createNewExpression, factoryDeprecation);
-  var updateNew = Debug.deprecate(factory.updateNewExpression, factoryDeprecation);
-  var createTypeAssertion = Debug.deprecate(factory.createTypeAssertion, factoryDeprecation);
-  var updateTypeAssertion = Debug.deprecate(factory.updateTypeAssertion, factoryDeprecation);
-  var createParen = Debug.deprecate(factory.createParenthesizedExpression, factoryDeprecation);
-  var updateParen = Debug.deprecate(factory.updateParenthesizedExpression, factoryDeprecation);
-  var createFunctionExpression = Debug.deprecate(factory.createFunctionExpression, factoryDeprecation);
-  var updateFunctionExpression = Debug.deprecate(factory.updateFunctionExpression, factoryDeprecation);
-  var createDelete = Debug.deprecate(factory.createDeleteExpression, factoryDeprecation);
-  var updateDelete = Debug.deprecate(factory.updateDeleteExpression, factoryDeprecation);
-  var createTypeOf = Debug.deprecate(factory.createTypeOfExpression, factoryDeprecation);
-  var updateTypeOf = Debug.deprecate(factory.updateTypeOfExpression, factoryDeprecation);
-  var createVoid = Debug.deprecate(factory.createVoidExpression, factoryDeprecation);
-  var updateVoid = Debug.deprecate(factory.updateVoidExpression, factoryDeprecation);
-  var createAwait = Debug.deprecate(factory.createAwaitExpression, factoryDeprecation);
-  var updateAwait = Debug.deprecate(factory.updateAwaitExpression, factoryDeprecation);
-  var createPrefix = Debug.deprecate(factory.createPrefixUnaryExpression, factoryDeprecation);
-  var updatePrefix = Debug.deprecate(factory.updatePrefixUnaryExpression, factoryDeprecation);
-  var createPostfix = Debug.deprecate(factory.createPostfixUnaryExpression, factoryDeprecation);
-  var updatePostfix = Debug.deprecate(factory.updatePostfixUnaryExpression, factoryDeprecation);
-  var createBinary = Debug.deprecate(factory.createBinaryExpression, factoryDeprecation);
-  var updateConditional = Debug.deprecate(factory.updateConditionalExpression, factoryDeprecation);
-  var createTemplateExpression = Debug.deprecate(factory.createTemplateExpression, factoryDeprecation);
-  var updateTemplateExpression = Debug.deprecate(factory.updateTemplateExpression, factoryDeprecation);
-  var createTemplateHead = Debug.deprecate(factory.createTemplateHead, factoryDeprecation);
-  var createTemplateMiddle = Debug.deprecate(factory.createTemplateMiddle, factoryDeprecation);
-  var createTemplateTail = Debug.deprecate(factory.createTemplateTail, factoryDeprecation);
-  var createNoSubstitutionTemplateLiteral = Debug.deprecate(factory.createNoSubstitutionTemplateLiteral, factoryDeprecation);
-  var updateYield = Debug.deprecate(factory.updateYieldExpression, factoryDeprecation);
-  var createSpread = Debug.deprecate(factory.createSpreadElement, factoryDeprecation);
-  var updateSpread = Debug.deprecate(factory.updateSpreadElement, factoryDeprecation);
-  var createOmittedExpression = Debug.deprecate(factory.createOmittedExpression, factoryDeprecation);
-  var createAsExpression = Debug.deprecate(factory.createAsExpression, factoryDeprecation);
-  var updateAsExpression = Debug.deprecate(factory.updateAsExpression, factoryDeprecation);
-  var createNonNullExpression = Debug.deprecate(factory.createNonNullExpression, factoryDeprecation);
-  var updateNonNullExpression = Debug.deprecate(factory.updateNonNullExpression, factoryDeprecation);
-  var createNonNullChain = Debug.deprecate(factory.createNonNullChain, factoryDeprecation);
-  var updateNonNullChain = Debug.deprecate(factory.updateNonNullChain, factoryDeprecation);
-  var createMetaProperty = Debug.deprecate(factory.createMetaProperty, factoryDeprecation);
-  var updateMetaProperty = Debug.deprecate(factory.updateMetaProperty, factoryDeprecation);
-  var createTemplateSpan = Debug.deprecate(factory.createTemplateSpan, factoryDeprecation);
-  var updateTemplateSpan = Debug.deprecate(factory.updateTemplateSpan, factoryDeprecation);
-  var createSemicolonClassElement = Debug.deprecate(factory.createSemicolonClassElement, factoryDeprecation);
-  var createBlock = Debug.deprecate(factory.createBlock, factoryDeprecation);
-  var updateBlock = Debug.deprecate(factory.updateBlock, factoryDeprecation);
-  var createVariableStatement = Debug.deprecate(factory.createVariableStatement, factoryDeprecation);
-  var updateVariableStatement = Debug.deprecate(factory.updateVariableStatement, factoryDeprecation);
-  var createEmptyStatement = Debug.deprecate(factory.createEmptyStatement, factoryDeprecation);
-  var createExpressionStatement = Debug.deprecate(factory.createExpressionStatement, factoryDeprecation);
-  var updateExpressionStatement = Debug.deprecate(factory.updateExpressionStatement, factoryDeprecation);
-  var createStatement = Debug.deprecate(factory.createExpressionStatement, factoryDeprecation);
-  var updateStatement = Debug.deprecate(factory.updateExpressionStatement, factoryDeprecation);
-  var createIf = Debug.deprecate(factory.createIfStatement, factoryDeprecation);
-  var updateIf = Debug.deprecate(factory.updateIfStatement, factoryDeprecation);
-  var createDo = Debug.deprecate(factory.createDoStatement, factoryDeprecation);
-  var updateDo = Debug.deprecate(factory.updateDoStatement, factoryDeprecation);
-  var createWhile = Debug.deprecate(factory.createWhileStatement, factoryDeprecation);
-  var updateWhile = Debug.deprecate(factory.updateWhileStatement, factoryDeprecation);
-  var createFor = Debug.deprecate(factory.createForStatement, factoryDeprecation);
-  var updateFor = Debug.deprecate(factory.updateForStatement, factoryDeprecation);
-  var createForIn = Debug.deprecate(factory.createForInStatement, factoryDeprecation);
-  var updateForIn = Debug.deprecate(factory.updateForInStatement, factoryDeprecation);
-  var createForOf = Debug.deprecate(factory.createForOfStatement, factoryDeprecation);
-  var updateForOf = Debug.deprecate(factory.updateForOfStatement, factoryDeprecation);
-  var createContinue = Debug.deprecate(factory.createContinueStatement, factoryDeprecation);
-  var updateContinue = Debug.deprecate(factory.updateContinueStatement, factoryDeprecation);
-  var createBreak = Debug.deprecate(factory.createBreakStatement, factoryDeprecation);
-  var updateBreak = Debug.deprecate(factory.updateBreakStatement, factoryDeprecation);
-  var createReturn = Debug.deprecate(factory.createReturnStatement, factoryDeprecation);
-  var updateReturn = Debug.deprecate(factory.updateReturnStatement, factoryDeprecation);
-  var createWith = Debug.deprecate(factory.createWithStatement, factoryDeprecation);
-  var updateWith = Debug.deprecate(factory.updateWithStatement, factoryDeprecation);
-  var createSwitch = Debug.deprecate(factory.createSwitchStatement, factoryDeprecation);
-  var updateSwitch = Debug.deprecate(factory.updateSwitchStatement, factoryDeprecation);
-  var createLabel = Debug.deprecate(factory.createLabeledStatement, factoryDeprecation);
-  var updateLabel = Debug.deprecate(factory.updateLabeledStatement, factoryDeprecation);
-  var createThrow = Debug.deprecate(factory.createThrowStatement, factoryDeprecation);
-  var updateThrow = Debug.deprecate(factory.updateThrowStatement, factoryDeprecation);
-  var createTry = Debug.deprecate(factory.createTryStatement, factoryDeprecation);
-  var updateTry = Debug.deprecate(factory.updateTryStatement, factoryDeprecation);
-  var createDebuggerStatement = Debug.deprecate(factory.createDebuggerStatement, factoryDeprecation);
-  var createVariableDeclarationList = Debug.deprecate(factory.createVariableDeclarationList, factoryDeprecation);
-  var updateVariableDeclarationList = Debug.deprecate(factory.updateVariableDeclarationList, factoryDeprecation);
-  var createFunctionDeclaration = Debug.deprecate(factory.createFunctionDeclaration, factoryDeprecation);
-  var updateFunctionDeclaration = Debug.deprecate(factory.updateFunctionDeclaration, factoryDeprecation);
-  var createClassDeclaration = Debug.deprecate(factory.createClassDeclaration, factoryDeprecation);
-  var updateClassDeclaration = Debug.deprecate(factory.updateClassDeclaration, factoryDeprecation);
-  var createInterfaceDeclaration = Debug.deprecate(factory.createInterfaceDeclaration, factoryDeprecation);
-  var updateInterfaceDeclaration = Debug.deprecate(factory.updateInterfaceDeclaration, factoryDeprecation);
-  var createTypeAliasDeclaration = Debug.deprecate(factory.createTypeAliasDeclaration, factoryDeprecation);
-  var updateTypeAliasDeclaration = Debug.deprecate(factory.updateTypeAliasDeclaration, factoryDeprecation);
-  var createEnumDeclaration = Debug.deprecate(factory.createEnumDeclaration, factoryDeprecation);
-  var updateEnumDeclaration = Debug.deprecate(factory.updateEnumDeclaration, factoryDeprecation);
-  var createModuleDeclaration = Debug.deprecate(factory.createModuleDeclaration, factoryDeprecation);
-  var updateModuleDeclaration = Debug.deprecate(factory.updateModuleDeclaration, factoryDeprecation);
-  var createModuleBlock = Debug.deprecate(factory.createModuleBlock, factoryDeprecation);
-  var updateModuleBlock = Debug.deprecate(factory.updateModuleBlock, factoryDeprecation);
-  var createCaseBlock = Debug.deprecate(factory.createCaseBlock, factoryDeprecation);
-  var updateCaseBlock = Debug.deprecate(factory.updateCaseBlock, factoryDeprecation);
-  var createNamespaceExportDeclaration = Debug.deprecate(factory.createNamespaceExportDeclaration, factoryDeprecation);
-  var updateNamespaceExportDeclaration = Debug.deprecate(factory.updateNamespaceExportDeclaration, factoryDeprecation);
-  var createImportEqualsDeclaration = Debug.deprecate(factory.createImportEqualsDeclaration, factoryDeprecation);
-  var updateImportEqualsDeclaration = Debug.deprecate(factory.updateImportEqualsDeclaration, factoryDeprecation);
-  var createImportDeclaration = Debug.deprecate(factory.createImportDeclaration, factoryDeprecation);
-  var updateImportDeclaration = Debug.deprecate(factory.updateImportDeclaration, factoryDeprecation);
-  var createNamespaceImport = Debug.deprecate(factory.createNamespaceImport, factoryDeprecation);
-  var updateNamespaceImport = Debug.deprecate(factory.updateNamespaceImport, factoryDeprecation);
-  var createNamedImports = Debug.deprecate(factory.createNamedImports, factoryDeprecation);
-  var updateNamedImports = Debug.deprecate(factory.updateNamedImports, factoryDeprecation);
-  var createImportSpecifier = Debug.deprecate(factory.createImportSpecifier, factoryDeprecation);
-  var updateImportSpecifier = Debug.deprecate(factory.updateImportSpecifier, factoryDeprecation);
-  var createExportAssignment2 = Debug.deprecate(factory.createExportAssignment, factoryDeprecation);
-  var updateExportAssignment = Debug.deprecate(factory.updateExportAssignment, factoryDeprecation);
-  var createNamedExports = Debug.deprecate(factory.createNamedExports, factoryDeprecation);
-  var updateNamedExports = Debug.deprecate(factory.updateNamedExports, factoryDeprecation);
-  var createExportSpecifier = Debug.deprecate(factory.createExportSpecifier, factoryDeprecation);
-  var updateExportSpecifier = Debug.deprecate(factory.updateExportSpecifier, factoryDeprecation);
-  var createExternalModuleReference = Debug.deprecate(factory.createExternalModuleReference, factoryDeprecation);
-  var updateExternalModuleReference = Debug.deprecate(factory.updateExternalModuleReference, factoryDeprecation);
-  var createJSDocTypeExpression = Debug.deprecate(factory.createJSDocTypeExpression, factoryDeprecation);
-  var createJSDocTypeTag = Debug.deprecate(factory.createJSDocTypeTag, factoryDeprecation);
-  var createJSDocReturnTag = Debug.deprecate(factory.createJSDocReturnTag, factoryDeprecation);
-  var createJSDocThisTag = Debug.deprecate(factory.createJSDocThisTag, factoryDeprecation);
-  var createJSDocComment = Debug.deprecate(factory.createJSDocComment, factoryDeprecation);
-  var createJSDocParameterTag = Debug.deprecate(factory.createJSDocParameterTag, factoryDeprecation);
-  var createJSDocClassTag = Debug.deprecate(factory.createJSDocClassTag, factoryDeprecation);
-  var createJSDocAugmentsTag = Debug.deprecate(factory.createJSDocAugmentsTag, factoryDeprecation);
-  var createJSDocEnumTag = Debug.deprecate(factory.createJSDocEnumTag, factoryDeprecation);
-  var createJSDocTemplateTag = Debug.deprecate(factory.createJSDocTemplateTag, factoryDeprecation);
-  var createJSDocTypedefTag = Debug.deprecate(factory.createJSDocTypedefTag, factoryDeprecation);
-  var createJSDocCallbackTag = Debug.deprecate(factory.createJSDocCallbackTag, factoryDeprecation);
-  var createJSDocSignature = Debug.deprecate(factory.createJSDocSignature, factoryDeprecation);
-  var createJSDocPropertyTag = Debug.deprecate(factory.createJSDocPropertyTag, factoryDeprecation);
-  var createJSDocTypeLiteral = Debug.deprecate(factory.createJSDocTypeLiteral, factoryDeprecation);
-  var createJSDocImplementsTag = Debug.deprecate(factory.createJSDocImplementsTag, factoryDeprecation);
-  var createJSDocAuthorTag = Debug.deprecate(factory.createJSDocAuthorTag, factoryDeprecation);
-  var createJSDocPublicTag = Debug.deprecate(factory.createJSDocPublicTag, factoryDeprecation);
-  var createJSDocPrivateTag = Debug.deprecate(factory.createJSDocPrivateTag, factoryDeprecation);
-  var createJSDocProtectedTag = Debug.deprecate(factory.createJSDocProtectedTag, factoryDeprecation);
-  var createJSDocReadonlyTag = Debug.deprecate(factory.createJSDocReadonlyTag, factoryDeprecation);
-  var createJSDocTag = Debug.deprecate(factory.createJSDocUnknownTag, factoryDeprecation);
-  var createJsxElement = Debug.deprecate(factory.createJsxElement, factoryDeprecation);
-  var updateJsxElement = Debug.deprecate(factory.updateJsxElement, factoryDeprecation);
-  var createJsxSelfClosingElement = Debug.deprecate(factory.createJsxSelfClosingElement, factoryDeprecation);
-  var updateJsxSelfClosingElement = Debug.deprecate(factory.updateJsxSelfClosingElement, factoryDeprecation);
-  var createJsxOpeningElement = Debug.deprecate(factory.createJsxOpeningElement, factoryDeprecation);
-  var updateJsxOpeningElement = Debug.deprecate(factory.updateJsxOpeningElement, factoryDeprecation);
-  var createJsxClosingElement = Debug.deprecate(factory.createJsxClosingElement, factoryDeprecation);
-  var updateJsxClosingElement = Debug.deprecate(factory.updateJsxClosingElement, factoryDeprecation);
-  var createJsxFragment = Debug.deprecate(factory.createJsxFragment, factoryDeprecation);
-  var createJsxText = Debug.deprecate(factory.createJsxText, factoryDeprecation);
-  var updateJsxText = Debug.deprecate(factory.updateJsxText, factoryDeprecation);
-  var createJsxOpeningFragment = Debug.deprecate(factory.createJsxOpeningFragment, factoryDeprecation);
-  var createJsxJsxClosingFragment = Debug.deprecate(factory.createJsxJsxClosingFragment, factoryDeprecation);
-  var updateJsxFragment = Debug.deprecate(factory.updateJsxFragment, factoryDeprecation);
-  var createJsxAttribute = Debug.deprecate(factory.createJsxAttribute, factoryDeprecation);
-  var updateJsxAttribute = Debug.deprecate(factory.updateJsxAttribute, factoryDeprecation);
-  var createJsxAttributes = Debug.deprecate(factory.createJsxAttributes, factoryDeprecation);
-  var updateJsxAttributes = Debug.deprecate(factory.updateJsxAttributes, factoryDeprecation);
-  var createJsxSpreadAttribute = Debug.deprecate(factory.createJsxSpreadAttribute, factoryDeprecation);
-  var updateJsxSpreadAttribute = Debug.deprecate(factory.updateJsxSpreadAttribute, factoryDeprecation);
-  var createJsxExpression = Debug.deprecate(factory.createJsxExpression, factoryDeprecation);
-  var updateJsxExpression = Debug.deprecate(factory.updateJsxExpression, factoryDeprecation);
-  var createCaseClause = Debug.deprecate(factory.createCaseClause, factoryDeprecation);
-  var updateCaseClause = Debug.deprecate(factory.updateCaseClause, factoryDeprecation);
-  var createDefaultClause = Debug.deprecate(factory.createDefaultClause, factoryDeprecation);
-  var updateDefaultClause = Debug.deprecate(factory.updateDefaultClause, factoryDeprecation);
-  var createHeritageClause = Debug.deprecate(factory.createHeritageClause, factoryDeprecation);
-  var updateHeritageClause = Debug.deprecate(factory.updateHeritageClause, factoryDeprecation);
-  var createCatchClause = Debug.deprecate(factory.createCatchClause, factoryDeprecation);
-  var updateCatchClause = Debug.deprecate(factory.updateCatchClause, factoryDeprecation);
-  var createPropertyAssignment = Debug.deprecate(factory.createPropertyAssignment, factoryDeprecation);
-  var updatePropertyAssignment = Debug.deprecate(factory.updatePropertyAssignment, factoryDeprecation);
-  var createShorthandPropertyAssignment = Debug.deprecate(factory.createShorthandPropertyAssignment, factoryDeprecation);
-  var updateShorthandPropertyAssignment = Debug.deprecate(factory.updateShorthandPropertyAssignment, factoryDeprecation);
-  var createSpreadAssignment = Debug.deprecate(factory.createSpreadAssignment, factoryDeprecation);
-  var updateSpreadAssignment = Debug.deprecate(factory.updateSpreadAssignment, factoryDeprecation);
-  var createEnumMember = Debug.deprecate(factory.createEnumMember, factoryDeprecation);
-  var updateEnumMember = Debug.deprecate(factory.updateEnumMember, factoryDeprecation);
-  var updateSourceFileNode = Debug.deprecate(factory.updateSourceFile, factoryDeprecation);
-  var createNotEmittedStatement = Debug.deprecate(factory.createNotEmittedStatement, factoryDeprecation);
-  var createPartiallyEmittedExpression = Debug.deprecate(factory.createPartiallyEmittedExpression, factoryDeprecation);
-  var updatePartiallyEmittedExpression = Debug.deprecate(factory.updatePartiallyEmittedExpression, factoryDeprecation);
-  var createCommaList = Debug.deprecate(factory.createCommaListExpression, factoryDeprecation);
-  var updateCommaList = Debug.deprecate(factory.updateCommaListExpression, factoryDeprecation);
-  var createBundle = Debug.deprecate(factory.createBundle, factoryDeprecation);
-  var updateBundle = Debug.deprecate(factory.updateBundle, factoryDeprecation);
-  var createImmediatelyInvokedFunctionExpression = Debug.deprecate(factory.createImmediatelyInvokedFunctionExpression, factoryDeprecation);
-  var createImmediatelyInvokedArrowFunction = Debug.deprecate(factory.createImmediatelyInvokedArrowFunction, factoryDeprecation);
-  var createVoidZero = Debug.deprecate(factory.createVoidZero, factoryDeprecation);
-  var createExportDefault = Debug.deprecate(factory.createExportDefault, factoryDeprecation);
-  var createExternalModuleExport = Debug.deprecate(factory.createExternalModuleExport, factoryDeprecation);
-  var createNamespaceExport = Debug.deprecate(factory.createNamespaceExport, factoryDeprecation);
-  var updateNamespaceExport = Debug.deprecate(factory.updateNamespaceExport, factoryDeprecation);
-  var createToken = Debug.deprecate(function createToken2(kind) {
+  var createTypeQueryNode = deprecate(factory.createTypeQueryNode, factoryDeprecation);
+  var updateTypeQueryNode = deprecate(factory.updateTypeQueryNode, factoryDeprecation);
+  var createTypeLiteralNode = deprecate(factory.createTypeLiteralNode, factoryDeprecation);
+  var updateTypeLiteralNode = deprecate(factory.updateTypeLiteralNode, factoryDeprecation);
+  var createArrayTypeNode = deprecate(factory.createArrayTypeNode, factoryDeprecation);
+  var updateArrayTypeNode = deprecate(factory.updateArrayTypeNode, factoryDeprecation);
+  var createTupleTypeNode = deprecate(factory.createTupleTypeNode, factoryDeprecation);
+  var updateTupleTypeNode = deprecate(factory.updateTupleTypeNode, factoryDeprecation);
+  var createOptionalTypeNode = deprecate(factory.createOptionalTypeNode, factoryDeprecation);
+  var updateOptionalTypeNode = deprecate(factory.updateOptionalTypeNode, factoryDeprecation);
+  var createRestTypeNode = deprecate(factory.createRestTypeNode, factoryDeprecation);
+  var updateRestTypeNode = deprecate(factory.updateRestTypeNode, factoryDeprecation);
+  var createUnionTypeNode = deprecate(factory.createUnionTypeNode, factoryDeprecation);
+  var updateUnionTypeNode = deprecate(factory.updateUnionTypeNode, factoryDeprecation);
+  var createIntersectionTypeNode = deprecate(factory.createIntersectionTypeNode, factoryDeprecation);
+  var updateIntersectionTypeNode = deprecate(factory.updateIntersectionTypeNode, factoryDeprecation);
+  var createConditionalTypeNode = deprecate(factory.createConditionalTypeNode, factoryDeprecation);
+  var updateConditionalTypeNode = deprecate(factory.updateConditionalTypeNode, factoryDeprecation);
+  var createInferTypeNode = deprecate(factory.createInferTypeNode, factoryDeprecation);
+  var updateInferTypeNode = deprecate(factory.updateInferTypeNode, factoryDeprecation);
+  var createImportTypeNode = deprecate(factory.createImportTypeNode, factoryDeprecation);
+  var updateImportTypeNode = deprecate(factory.updateImportTypeNode, factoryDeprecation);
+  var createParenthesizedType = deprecate(factory.createParenthesizedType, factoryDeprecation);
+  var updateParenthesizedType = deprecate(factory.updateParenthesizedType, factoryDeprecation);
+  var createThisTypeNode = deprecate(factory.createThisTypeNode, factoryDeprecation);
+  var updateTypeOperatorNode = deprecate(factory.updateTypeOperatorNode, factoryDeprecation);
+  var createIndexedAccessTypeNode = deprecate(factory.createIndexedAccessTypeNode, factoryDeprecation);
+  var updateIndexedAccessTypeNode = deprecate(factory.updateIndexedAccessTypeNode, factoryDeprecation);
+  var createMappedTypeNode = deprecate(factory.createMappedTypeNode, factoryDeprecation);
+  var updateMappedTypeNode = deprecate(factory.updateMappedTypeNode, factoryDeprecation);
+  var createLiteralTypeNode = deprecate(factory.createLiteralTypeNode, factoryDeprecation);
+  var updateLiteralTypeNode = deprecate(factory.updateLiteralTypeNode, factoryDeprecation);
+  var createObjectBindingPattern = deprecate(factory.createObjectBindingPattern, factoryDeprecation);
+  var updateObjectBindingPattern = deprecate(factory.updateObjectBindingPattern, factoryDeprecation);
+  var createArrayBindingPattern = deprecate(factory.createArrayBindingPattern, factoryDeprecation);
+  var updateArrayBindingPattern = deprecate(factory.updateArrayBindingPattern, factoryDeprecation);
+  var createBindingElement = deprecate(factory.createBindingElement, factoryDeprecation);
+  var updateBindingElement = deprecate(factory.updateBindingElement, factoryDeprecation);
+  var createArrayLiteral = deprecate(factory.createArrayLiteralExpression, factoryDeprecation);
+  var updateArrayLiteral = deprecate(factory.updateArrayLiteralExpression, factoryDeprecation);
+  var createObjectLiteral = deprecate(factory.createObjectLiteralExpression, factoryDeprecation);
+  var updateObjectLiteral = deprecate(factory.updateObjectLiteralExpression, factoryDeprecation);
+  var createPropertyAccess = deprecate(factory.createPropertyAccessExpression, factoryDeprecation);
+  var updatePropertyAccess = deprecate(factory.updatePropertyAccessExpression, factoryDeprecation);
+  var createPropertyAccessChain = deprecate(factory.createPropertyAccessChain, factoryDeprecation);
+  var updatePropertyAccessChain = deprecate(factory.updatePropertyAccessChain, factoryDeprecation);
+  var createElementAccess = deprecate(factory.createElementAccessExpression, factoryDeprecation);
+  var updateElementAccess = deprecate(factory.updateElementAccessExpression, factoryDeprecation);
+  var createElementAccessChain = deprecate(factory.createElementAccessChain, factoryDeprecation);
+  var updateElementAccessChain = deprecate(factory.updateElementAccessChain, factoryDeprecation);
+  var createCall = deprecate(factory.createCallExpression, factoryDeprecation);
+  var updateCall = deprecate(factory.updateCallExpression, factoryDeprecation);
+  var createCallChain = deprecate(factory.createCallChain, factoryDeprecation);
+  var updateCallChain = deprecate(factory.updateCallChain, factoryDeprecation);
+  var createNew = deprecate(factory.createNewExpression, factoryDeprecation);
+  var updateNew = deprecate(factory.updateNewExpression, factoryDeprecation);
+  var createTypeAssertion = deprecate(factory.createTypeAssertion, factoryDeprecation);
+  var updateTypeAssertion = deprecate(factory.updateTypeAssertion, factoryDeprecation);
+  var createParen = deprecate(factory.createParenthesizedExpression, factoryDeprecation);
+  var updateParen = deprecate(factory.updateParenthesizedExpression, factoryDeprecation);
+  var createFunctionExpression = deprecate(factory.createFunctionExpression, factoryDeprecation);
+  var updateFunctionExpression = deprecate(factory.updateFunctionExpression, factoryDeprecation);
+  var createDelete = deprecate(factory.createDeleteExpression, factoryDeprecation);
+  var updateDelete = deprecate(factory.updateDeleteExpression, factoryDeprecation);
+  var createTypeOf = deprecate(factory.createTypeOfExpression, factoryDeprecation);
+  var updateTypeOf = deprecate(factory.updateTypeOfExpression, factoryDeprecation);
+  var createVoid = deprecate(factory.createVoidExpression, factoryDeprecation);
+  var updateVoid = deprecate(factory.updateVoidExpression, factoryDeprecation);
+  var createAwait = deprecate(factory.createAwaitExpression, factoryDeprecation);
+  var updateAwait = deprecate(factory.updateAwaitExpression, factoryDeprecation);
+  var createPrefix = deprecate(factory.createPrefixUnaryExpression, factoryDeprecation);
+  var updatePrefix = deprecate(factory.updatePrefixUnaryExpression, factoryDeprecation);
+  var createPostfix = deprecate(factory.createPostfixUnaryExpression, factoryDeprecation);
+  var updatePostfix = deprecate(factory.updatePostfixUnaryExpression, factoryDeprecation);
+  var createBinary = deprecate(factory.createBinaryExpression, factoryDeprecation);
+  var updateConditional = deprecate(factory.updateConditionalExpression, factoryDeprecation);
+  var createTemplateExpression = deprecate(factory.createTemplateExpression, factoryDeprecation);
+  var updateTemplateExpression = deprecate(factory.updateTemplateExpression, factoryDeprecation);
+  var createTemplateHead = deprecate(factory.createTemplateHead, factoryDeprecation);
+  var createTemplateMiddle = deprecate(factory.createTemplateMiddle, factoryDeprecation);
+  var createTemplateTail = deprecate(factory.createTemplateTail, factoryDeprecation);
+  var createNoSubstitutionTemplateLiteral = deprecate(factory.createNoSubstitutionTemplateLiteral, factoryDeprecation);
+  var updateYield = deprecate(factory.updateYieldExpression, factoryDeprecation);
+  var createSpread = deprecate(factory.createSpreadElement, factoryDeprecation);
+  var updateSpread = deprecate(factory.updateSpreadElement, factoryDeprecation);
+  var createOmittedExpression = deprecate(factory.createOmittedExpression, factoryDeprecation);
+  var createAsExpression = deprecate(factory.createAsExpression, factoryDeprecation);
+  var updateAsExpression = deprecate(factory.updateAsExpression, factoryDeprecation);
+  var createNonNullExpression = deprecate(factory.createNonNullExpression, factoryDeprecation);
+  var updateNonNullExpression = deprecate(factory.updateNonNullExpression, factoryDeprecation);
+  var createNonNullChain = deprecate(factory.createNonNullChain, factoryDeprecation);
+  var updateNonNullChain = deprecate(factory.updateNonNullChain, factoryDeprecation);
+  var createMetaProperty = deprecate(factory.createMetaProperty, factoryDeprecation);
+  var updateMetaProperty = deprecate(factory.updateMetaProperty, factoryDeprecation);
+  var createTemplateSpan = deprecate(factory.createTemplateSpan, factoryDeprecation);
+  var updateTemplateSpan = deprecate(factory.updateTemplateSpan, factoryDeprecation);
+  var createSemicolonClassElement = deprecate(factory.createSemicolonClassElement, factoryDeprecation);
+  var createBlock = deprecate(factory.createBlock, factoryDeprecation);
+  var updateBlock = deprecate(factory.updateBlock, factoryDeprecation);
+  var createVariableStatement = deprecate(factory.createVariableStatement, factoryDeprecation);
+  var updateVariableStatement = deprecate(factory.updateVariableStatement, factoryDeprecation);
+  var createEmptyStatement = deprecate(factory.createEmptyStatement, factoryDeprecation);
+  var createExpressionStatement = deprecate(factory.createExpressionStatement, factoryDeprecation);
+  var updateExpressionStatement = deprecate(factory.updateExpressionStatement, factoryDeprecation);
+  var createStatement = deprecate(factory.createExpressionStatement, factoryDeprecation);
+  var updateStatement = deprecate(factory.updateExpressionStatement, factoryDeprecation);
+  var createIf = deprecate(factory.createIfStatement, factoryDeprecation);
+  var updateIf = deprecate(factory.updateIfStatement, factoryDeprecation);
+  var createDo = deprecate(factory.createDoStatement, factoryDeprecation);
+  var updateDo = deprecate(factory.updateDoStatement, factoryDeprecation);
+  var createWhile = deprecate(factory.createWhileStatement, factoryDeprecation);
+  var updateWhile = deprecate(factory.updateWhileStatement, factoryDeprecation);
+  var createFor = deprecate(factory.createForStatement, factoryDeprecation);
+  var updateFor = deprecate(factory.updateForStatement, factoryDeprecation);
+  var createForIn = deprecate(factory.createForInStatement, factoryDeprecation);
+  var updateForIn = deprecate(factory.updateForInStatement, factoryDeprecation);
+  var createForOf = deprecate(factory.createForOfStatement, factoryDeprecation);
+  var updateForOf = deprecate(factory.updateForOfStatement, factoryDeprecation);
+  var createContinue = deprecate(factory.createContinueStatement, factoryDeprecation);
+  var updateContinue = deprecate(factory.updateContinueStatement, factoryDeprecation);
+  var createBreak = deprecate(factory.createBreakStatement, factoryDeprecation);
+  var updateBreak = deprecate(factory.updateBreakStatement, factoryDeprecation);
+  var createReturn = deprecate(factory.createReturnStatement, factoryDeprecation);
+  var updateReturn = deprecate(factory.updateReturnStatement, factoryDeprecation);
+  var createWith = deprecate(factory.createWithStatement, factoryDeprecation);
+  var updateWith = deprecate(factory.updateWithStatement, factoryDeprecation);
+  var createSwitch = deprecate(factory.createSwitchStatement, factoryDeprecation);
+  var updateSwitch = deprecate(factory.updateSwitchStatement, factoryDeprecation);
+  var createLabel = deprecate(factory.createLabeledStatement, factoryDeprecation);
+  var updateLabel = deprecate(factory.updateLabeledStatement, factoryDeprecation);
+  var createThrow = deprecate(factory.createThrowStatement, factoryDeprecation);
+  var updateThrow = deprecate(factory.updateThrowStatement, factoryDeprecation);
+  var createTry = deprecate(factory.createTryStatement, factoryDeprecation);
+  var updateTry = deprecate(factory.updateTryStatement, factoryDeprecation);
+  var createDebuggerStatement = deprecate(factory.createDebuggerStatement, factoryDeprecation);
+  var createVariableDeclarationList = deprecate(factory.createVariableDeclarationList, factoryDeprecation);
+  var updateVariableDeclarationList = deprecate(factory.updateVariableDeclarationList, factoryDeprecation);
+  var createFunctionDeclaration = deprecate(factory.createFunctionDeclaration, factoryDeprecation);
+  var updateFunctionDeclaration = deprecate(factory.updateFunctionDeclaration, factoryDeprecation);
+  var createClassDeclaration = deprecate(factory.createClassDeclaration, factoryDeprecation);
+  var updateClassDeclaration = deprecate(factory.updateClassDeclaration, factoryDeprecation);
+  var createInterfaceDeclaration = deprecate(factory.createInterfaceDeclaration, factoryDeprecation);
+  var updateInterfaceDeclaration = deprecate(factory.updateInterfaceDeclaration, factoryDeprecation);
+  var createTypeAliasDeclaration = deprecate(factory.createTypeAliasDeclaration, factoryDeprecation);
+  var updateTypeAliasDeclaration = deprecate(factory.updateTypeAliasDeclaration, factoryDeprecation);
+  var createEnumDeclaration = deprecate(factory.createEnumDeclaration, factoryDeprecation);
+  var updateEnumDeclaration = deprecate(factory.updateEnumDeclaration, factoryDeprecation);
+  var createModuleDeclaration = deprecate(factory.createModuleDeclaration, factoryDeprecation);
+  var updateModuleDeclaration = deprecate(factory.updateModuleDeclaration, factoryDeprecation);
+  var createModuleBlock = deprecate(factory.createModuleBlock, factoryDeprecation);
+  var updateModuleBlock = deprecate(factory.updateModuleBlock, factoryDeprecation);
+  var createCaseBlock = deprecate(factory.createCaseBlock, factoryDeprecation);
+  var updateCaseBlock = deprecate(factory.updateCaseBlock, factoryDeprecation);
+  var createNamespaceExportDeclaration = deprecate(factory.createNamespaceExportDeclaration, factoryDeprecation);
+  var updateNamespaceExportDeclaration = deprecate(factory.updateNamespaceExportDeclaration, factoryDeprecation);
+  var createImportEqualsDeclaration = deprecate(factory.createImportEqualsDeclaration, factoryDeprecation);
+  var updateImportEqualsDeclaration = deprecate(factory.updateImportEqualsDeclaration, factoryDeprecation);
+  var createImportDeclaration = deprecate(factory.createImportDeclaration, factoryDeprecation);
+  var updateImportDeclaration = deprecate(factory.updateImportDeclaration, factoryDeprecation);
+  var createNamespaceImport = deprecate(factory.createNamespaceImport, factoryDeprecation);
+  var updateNamespaceImport = deprecate(factory.updateNamespaceImport, factoryDeprecation);
+  var createNamedImports = deprecate(factory.createNamedImports, factoryDeprecation);
+  var updateNamedImports = deprecate(factory.updateNamedImports, factoryDeprecation);
+  var createImportSpecifier = deprecate(factory.createImportSpecifier, factoryDeprecation);
+  var updateImportSpecifier = deprecate(factory.updateImportSpecifier, factoryDeprecation);
+  var createExportAssignment2 = deprecate(factory.createExportAssignment, factoryDeprecation);
+  var updateExportAssignment = deprecate(factory.updateExportAssignment, factoryDeprecation);
+  var createNamedExports = deprecate(factory.createNamedExports, factoryDeprecation);
+  var updateNamedExports = deprecate(factory.updateNamedExports, factoryDeprecation);
+  var createExportSpecifier = deprecate(factory.createExportSpecifier, factoryDeprecation);
+  var updateExportSpecifier = deprecate(factory.updateExportSpecifier, factoryDeprecation);
+  var createExternalModuleReference = deprecate(factory.createExternalModuleReference, factoryDeprecation);
+  var updateExternalModuleReference = deprecate(factory.updateExternalModuleReference, factoryDeprecation);
+  var createJSDocTypeExpression = deprecate(factory.createJSDocTypeExpression, factoryDeprecation);
+  var createJSDocTypeTag = deprecate(factory.createJSDocTypeTag, factoryDeprecation);
+  var createJSDocReturnTag = deprecate(factory.createJSDocReturnTag, factoryDeprecation);
+  var createJSDocThisTag = deprecate(factory.createJSDocThisTag, factoryDeprecation);
+  var createJSDocComment = deprecate(factory.createJSDocComment, factoryDeprecation);
+  var createJSDocParameterTag = deprecate(factory.createJSDocParameterTag, factoryDeprecation);
+  var createJSDocClassTag = deprecate(factory.createJSDocClassTag, factoryDeprecation);
+  var createJSDocAugmentsTag = deprecate(factory.createJSDocAugmentsTag, factoryDeprecation);
+  var createJSDocEnumTag = deprecate(factory.createJSDocEnumTag, factoryDeprecation);
+  var createJSDocTemplateTag = deprecate(factory.createJSDocTemplateTag, factoryDeprecation);
+  var createJSDocTypedefTag = deprecate(factory.createJSDocTypedefTag, factoryDeprecation);
+  var createJSDocCallbackTag = deprecate(factory.createJSDocCallbackTag, factoryDeprecation);
+  var createJSDocSignature = deprecate(factory.createJSDocSignature, factoryDeprecation);
+  var createJSDocPropertyTag = deprecate(factory.createJSDocPropertyTag, factoryDeprecation);
+  var createJSDocTypeLiteral = deprecate(factory.createJSDocTypeLiteral, factoryDeprecation);
+  var createJSDocImplementsTag = deprecate(factory.createJSDocImplementsTag, factoryDeprecation);
+  var createJSDocAuthorTag = deprecate(factory.createJSDocAuthorTag, factoryDeprecation);
+  var createJSDocPublicTag = deprecate(factory.createJSDocPublicTag, factoryDeprecation);
+  var createJSDocPrivateTag = deprecate(factory.createJSDocPrivateTag, factoryDeprecation);
+  var createJSDocProtectedTag = deprecate(factory.createJSDocProtectedTag, factoryDeprecation);
+  var createJSDocReadonlyTag = deprecate(factory.createJSDocReadonlyTag, factoryDeprecation);
+  var createJSDocTag = deprecate(factory.createJSDocUnknownTag, factoryDeprecation);
+  var createJsxElement = deprecate(factory.createJsxElement, factoryDeprecation);
+  var updateJsxElement = deprecate(factory.updateJsxElement, factoryDeprecation);
+  var createJsxSelfClosingElement = deprecate(factory.createJsxSelfClosingElement, factoryDeprecation);
+  var updateJsxSelfClosingElement = deprecate(factory.updateJsxSelfClosingElement, factoryDeprecation);
+  var createJsxOpeningElement = deprecate(factory.createJsxOpeningElement, factoryDeprecation);
+  var updateJsxOpeningElement = deprecate(factory.updateJsxOpeningElement, factoryDeprecation);
+  var createJsxClosingElement = deprecate(factory.createJsxClosingElement, factoryDeprecation);
+  var updateJsxClosingElement = deprecate(factory.updateJsxClosingElement, factoryDeprecation);
+  var createJsxFragment = deprecate(factory.createJsxFragment, factoryDeprecation);
+  var createJsxText = deprecate(factory.createJsxText, factoryDeprecation);
+  var updateJsxText = deprecate(factory.updateJsxText, factoryDeprecation);
+  var createJsxOpeningFragment = deprecate(factory.createJsxOpeningFragment, factoryDeprecation);
+  var createJsxJsxClosingFragment = deprecate(factory.createJsxJsxClosingFragment, factoryDeprecation);
+  var updateJsxFragment = deprecate(factory.updateJsxFragment, factoryDeprecation);
+  var createJsxAttribute = deprecate(factory.createJsxAttribute, factoryDeprecation);
+  var updateJsxAttribute = deprecate(factory.updateJsxAttribute, factoryDeprecation);
+  var createJsxAttributes = deprecate(factory.createJsxAttributes, factoryDeprecation);
+  var updateJsxAttributes = deprecate(factory.updateJsxAttributes, factoryDeprecation);
+  var createJsxSpreadAttribute = deprecate(factory.createJsxSpreadAttribute, factoryDeprecation);
+  var updateJsxSpreadAttribute = deprecate(factory.updateJsxSpreadAttribute, factoryDeprecation);
+  var createJsxExpression = deprecate(factory.createJsxExpression, factoryDeprecation);
+  var updateJsxExpression = deprecate(factory.updateJsxExpression, factoryDeprecation);
+  var createCaseClause = deprecate(factory.createCaseClause, factoryDeprecation);
+  var updateCaseClause = deprecate(factory.updateCaseClause, factoryDeprecation);
+  var createDefaultClause = deprecate(factory.createDefaultClause, factoryDeprecation);
+  var updateDefaultClause = deprecate(factory.updateDefaultClause, factoryDeprecation);
+  var createHeritageClause = deprecate(factory.createHeritageClause, factoryDeprecation);
+  var updateHeritageClause = deprecate(factory.updateHeritageClause, factoryDeprecation);
+  var createCatchClause = deprecate(factory.createCatchClause, factoryDeprecation);
+  var updateCatchClause = deprecate(factory.updateCatchClause, factoryDeprecation);
+  var createPropertyAssignment = deprecate(factory.createPropertyAssignment, factoryDeprecation);
+  var updatePropertyAssignment = deprecate(factory.updatePropertyAssignment, factoryDeprecation);
+  var createShorthandPropertyAssignment = deprecate(factory.createShorthandPropertyAssignment, factoryDeprecation);
+  var updateShorthandPropertyAssignment = deprecate(factory.updateShorthandPropertyAssignment, factoryDeprecation);
+  var createSpreadAssignment = deprecate(factory.createSpreadAssignment, factoryDeprecation);
+  var updateSpreadAssignment = deprecate(factory.updateSpreadAssignment, factoryDeprecation);
+  var createEnumMember = deprecate(factory.createEnumMember, factoryDeprecation);
+  var updateEnumMember = deprecate(factory.updateEnumMember, factoryDeprecation);
+  var updateSourceFileNode = deprecate(factory.updateSourceFile, factoryDeprecation);
+  var createNotEmittedStatement = deprecate(factory.createNotEmittedStatement, factoryDeprecation);
+  var createPartiallyEmittedExpression = deprecate(factory.createPartiallyEmittedExpression, factoryDeprecation);
+  var updatePartiallyEmittedExpression = deprecate(factory.updatePartiallyEmittedExpression, factoryDeprecation);
+  var createCommaList = deprecate(factory.createCommaListExpression, factoryDeprecation);
+  var updateCommaList = deprecate(factory.updateCommaListExpression, factoryDeprecation);
+  var createBundle = deprecate(factory.createBundle, factoryDeprecation);
+  var updateBundle = deprecate(factory.updateBundle, factoryDeprecation);
+  var createImmediatelyInvokedFunctionExpression = deprecate(factory.createImmediatelyInvokedFunctionExpression, factoryDeprecation);
+  var createImmediatelyInvokedArrowFunction = deprecate(factory.createImmediatelyInvokedArrowFunction, factoryDeprecation);
+  var createVoidZero = deprecate(factory.createVoidZero, factoryDeprecation);
+  var createExportDefault = deprecate(factory.createExportDefault, factoryDeprecation);
+  var createExternalModuleExport = deprecate(factory.createExternalModuleExport, factoryDeprecation);
+  var createNamespaceExport = deprecate(factory.createNamespaceExport, factoryDeprecation);
+  var updateNamespaceExport = deprecate(factory.updateNamespaceExport, factoryDeprecation);
+  var createToken = deprecate(function createToken2(kind) {
     return factory.createToken(kind);
   }, factoryDeprecation);
-  var createIdentifier = Debug.deprecate(function createIdentifier2(text) {
+  var createIdentifier = deprecate(function createIdentifier2(text) {
     return factory.createIdentifier(text, void 0, void 0);
   }, factoryDeprecation);
-  var createTempVariable = Debug.deprecate(function createTempVariable2(recordTempVariable) {
+  var createTempVariable = deprecate(function createTempVariable2(recordTempVariable) {
     return factory.createTempVariable(recordTempVariable, void 0);
   }, factoryDeprecation);
-  var getGeneratedNameForNode = Debug.deprecate(function getGeneratedNameForNode2(node) {
+  var getGeneratedNameForNode = deprecate(function getGeneratedNameForNode2(node) {
     return factory.getGeneratedNameForNode(node, void 0);
   }, factoryDeprecation);
-  var createOptimisticUniqueName = Debug.deprecate(function createOptimisticUniqueName2(text) {
+  var createOptimisticUniqueName = deprecate(function createOptimisticUniqueName2(text) {
     return factory.createUniqueName(text, 16 /* Optimistic */);
   }, factoryDeprecation);
-  var createFileLevelUniqueName = Debug.deprecate(function createFileLevelUniqueName2(text) {
+  var createFileLevelUniqueName = deprecate(function createFileLevelUniqueName2(text) {
     return factory.createUniqueName(text, 16 /* Optimistic */ | 32 /* FileLevel */);
   }, factoryDeprecation);
-  var createIndexSignature = Debug.deprecate(function createIndexSignature2(decorators, modifiers, parameters, type) {
+  var createIndexSignature = deprecate(function createIndexSignature2(decorators, modifiers, parameters, type) {
     return factory.createIndexSignature(decorators, modifiers, parameters, type);
   }, factoryDeprecation);
-  var createTypePredicateNode = Debug.deprecate(function createTypePredicateNode2(parameterName, type) {
+  var createTypePredicateNode = deprecate(function createTypePredicateNode2(parameterName, type) {
     return factory.createTypePredicateNode(void 0, parameterName, type);
   }, factoryDeprecation);
-  var updateTypePredicateNode = Debug.deprecate(function updateTypePredicateNode2(node, parameterName, type) {
+  var updateTypePredicateNode = deprecate(function updateTypePredicateNode2(node, parameterName, type) {
     return factory.updateTypePredicateNode(node, void 0, parameterName, type);
   }, factoryDeprecation);
-  var createLiteral = Debug.deprecate(function createLiteral2(value) {
+  var createLiteral = deprecate(function createLiteral2(value) {
     if (typeof value === "number") {
       return factory.createNumericLiteral(value);
     }
@@ -150659,13 +150649,13 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return factory.createStringLiteralFromNode(value);
   }, { since: "4.0", warnAfter: "4.1", message: "Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead." });
-  var createMethodSignature = Debug.deprecate(function createMethodSignature2(typeParameters, parameters, type, name, questionToken) {
+  var createMethodSignature = deprecate(function createMethodSignature2(typeParameters, parameters, type, name, questionToken) {
     return factory.createMethodSignature(void 0, name, questionToken, typeParameters, parameters, type);
   }, factoryDeprecation);
-  var updateMethodSignature = Debug.deprecate(function updateMethodSignature2(node, typeParameters, parameters, type, name, questionToken) {
+  var updateMethodSignature = deprecate(function updateMethodSignature2(node, typeParameters, parameters, type, name, questionToken) {
     return factory.updateMethodSignature(node, node.modifiers, name, questionToken, typeParameters, parameters, type);
   }, factoryDeprecation);
-  var createTypeOperatorNode = Debug.deprecate(function createTypeOperatorNode2(operatorOrType, type) {
+  var createTypeOperatorNode = deprecate(function createTypeOperatorNode2(operatorOrType, type) {
     let operator;
     if (type) {
       operator = operatorOrType;
@@ -150675,7 +150665,7 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return factory.createTypeOperatorNode(operator, type);
   }, factoryDeprecation);
-  var createTaggedTemplate = Debug.deprecate(function createTaggedTemplate2(tag, typeArgumentsOrTemplate, template) {
+  var createTaggedTemplate = deprecate(function createTaggedTemplate2(tag, typeArgumentsOrTemplate, template) {
     let typeArguments;
     if (template) {
       typeArguments = typeArgumentsOrTemplate;
@@ -150684,7 +150674,7 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return factory.createTaggedTemplateExpression(tag, typeArguments, template);
   }, factoryDeprecation);
-  var updateTaggedTemplate = Debug.deprecate(function updateTaggedTemplate2(node, tag, typeArgumentsOrTemplate, template) {
+  var updateTaggedTemplate = deprecate(function updateTaggedTemplate2(node, tag, typeArgumentsOrTemplate, template) {
     let typeArguments;
     if (template) {
       typeArguments = typeArgumentsOrTemplate;
@@ -150693,16 +150683,16 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return factory.updateTaggedTemplateExpression(node, tag, typeArguments, template);
   }, factoryDeprecation);
-  var updateBinary = Debug.deprecate(function updateBinary2(node, left, right, operator = node.operatorToken) {
+  var updateBinary = deprecate(function updateBinary2(node, left, right, operator = node.operatorToken) {
     if (typeof operator === "number") {
       operator = operator === node.operatorToken.kind ? node.operatorToken : factory.createToken(operator);
     }
     return factory.updateBinaryExpression(node, left, operator, right);
   }, factoryDeprecation);
-  var createConditional = Debug.deprecate(function createConditional2(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) {
+  var createConditional = deprecate(function createConditional2(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) {
     return arguments.length === 5 ? factory.createConditionalExpression(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) : arguments.length === 3 ? factory.createConditionalExpression(condition, factory.createToken(57 /* QuestionToken */), questionTokenOrWhenTrue, factory.createToken(58 /* ColonToken */), whenTrueOrWhenFalse) : Debug.fail("Argument count mismatch");
   }, factoryDeprecation);
-  var createYield = Debug.deprecate(function createYield2(asteriskTokenOrExpression, expression) {
+  var createYield = deprecate(function createYield2(asteriskTokenOrExpression, expression) {
     let asteriskToken;
     if (expression) {
       asteriskToken = asteriskTokenOrExpression;
@@ -150711,18 +150701,18 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return factory.createYieldExpression(asteriskToken, expression);
   }, factoryDeprecation);
-  var createClassExpression = Debug.deprecate(function createClassExpression2(modifiers, name, typeParameters, heritageClauses, members) {
+  var createClassExpression = deprecate(function createClassExpression2(modifiers, name, typeParameters, heritageClauses, members) {
     return factory.createClassExpression(void 0, modifiers, name, typeParameters, heritageClauses, members);
   }, factoryDeprecation);
-  var updateClassExpression = Debug.deprecate(function updateClassExpression2(node, modifiers, name, typeParameters, heritageClauses, members) {
+  var updateClassExpression = deprecate(function updateClassExpression2(node, modifiers, name, typeParameters, heritageClauses, members) {
     return factory.updateClassExpression(node, void 0, modifiers, name, typeParameters, heritageClauses, members);
   }, factoryDeprecation);
-  var createPropertySignature = Debug.deprecate(function createPropertySignature2(modifiers, name, questionToken, type, initializer) {
+  var createPropertySignature = deprecate(function createPropertySignature2(modifiers, name, questionToken, type, initializer) {
     const node = factory.createPropertySignature(modifiers, name, questionToken, type);
     node.initializer = initializer;
     return node;
   }, factoryDeprecation);
-  var updatePropertySignature = Debug.deprecate(function updatePropertySignature2(node, modifiers, name, questionToken, type, initializer) {
+  var updatePropertySignature = deprecate(function updatePropertySignature2(node, modifiers, name, questionToken, type, initializer) {
     let updated = factory.updatePropertySignature(node, modifiers, name, questionToken, type);
     if (node.initializer !== initializer) {
       if (updated === node) {
@@ -150732,80 +150722,80 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return updated;
   }, factoryDeprecation);
-  var createExpressionWithTypeArguments = Debug.deprecate(function createExpressionWithTypeArguments2(typeArguments, expression) {
+  var createExpressionWithTypeArguments = deprecate(function createExpressionWithTypeArguments2(typeArguments, expression) {
     return factory.createExpressionWithTypeArguments(expression, typeArguments);
   }, factoryDeprecation);
-  var updateExpressionWithTypeArguments = Debug.deprecate(function updateExpressionWithTypeArguments2(node, typeArguments, expression) {
+  var updateExpressionWithTypeArguments = deprecate(function updateExpressionWithTypeArguments2(node, typeArguments, expression) {
     return factory.updateExpressionWithTypeArguments(node, expression, typeArguments);
   }, factoryDeprecation);
-  var createArrowFunction = Debug.deprecate(function createArrowFunction2(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
+  var createArrowFunction = deprecate(function createArrowFunction2(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
     return arguments.length === 6 ? factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) : arguments.length === 5 ? factory.createArrowFunction(modifiers, typeParameters, parameters, type, void 0, equalsGreaterThanTokenOrBody) : Debug.fail("Argument count mismatch");
   }, factoryDeprecation);
-  var updateArrowFunction = Debug.deprecate(function updateArrowFunction2(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
+  var updateArrowFunction = deprecate(function updateArrowFunction2(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
     return arguments.length === 7 ? factory.updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) : arguments.length === 6 ? factory.updateArrowFunction(node, modifiers, typeParameters, parameters, type, node.equalsGreaterThanToken, equalsGreaterThanTokenOrBody) : Debug.fail("Argument count mismatch");
   }, factoryDeprecation);
-  var createVariableDeclaration = Debug.deprecate(function createVariableDeclaration2(name, exclamationTokenOrType, typeOrInitializer, initializer) {
+  var createVariableDeclaration = deprecate(function createVariableDeclaration2(name, exclamationTokenOrType, typeOrInitializer, initializer) {
     return arguments.length === 4 ? factory.createVariableDeclaration(name, exclamationTokenOrType, typeOrInitializer, initializer) : arguments.length >= 1 && arguments.length <= 3 ? factory.createVariableDeclaration(name, void 0, exclamationTokenOrType, typeOrInitializer) : Debug.fail("Argument count mismatch");
   }, factoryDeprecation);
-  var updateVariableDeclaration = Debug.deprecate(function updateVariableDeclaration2(node, name, exclamationTokenOrType, typeOrInitializer, initializer) {
+  var updateVariableDeclaration = deprecate(function updateVariableDeclaration2(node, name, exclamationTokenOrType, typeOrInitializer, initializer) {
     return arguments.length === 5 ? factory.updateVariableDeclaration(node, name, exclamationTokenOrType, typeOrInitializer, initializer) : arguments.length === 4 ? factory.updateVariableDeclaration(node, name, node.exclamationToken, exclamationTokenOrType, typeOrInitializer) : Debug.fail("Argument count mismatch");
   }, factoryDeprecation);
-  var createImportClause = Debug.deprecate(function createImportClause2(name, namedBindings, isTypeOnly = false) {
+  var createImportClause = deprecate(function createImportClause2(name, namedBindings, isTypeOnly = false) {
     return factory.createImportClause(isTypeOnly, name, namedBindings);
   }, factoryDeprecation);
-  var updateImportClause = Debug.deprecate(function updateImportClause2(node, name, namedBindings, isTypeOnly) {
+  var updateImportClause = deprecate(function updateImportClause2(node, name, namedBindings, isTypeOnly) {
     return factory.updateImportClause(node, isTypeOnly, name, namedBindings);
   }, factoryDeprecation);
-  var createExportDeclaration = Debug.deprecate(function createExportDeclaration2(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly = false) {
+  var createExportDeclaration = deprecate(function createExportDeclaration2(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly = false) {
     return factory.createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier);
   }, factoryDeprecation);
-  var updateExportDeclaration = Debug.deprecate(function updateExportDeclaration2(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
+  var updateExportDeclaration = deprecate(function updateExportDeclaration2(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
     return factory.updateExportDeclaration(node, decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, node.assertClause);
   }, factoryDeprecation);
-  var createJSDocParamTag = Debug.deprecate(function createJSDocParamTag2(name, isBracketed, typeExpression, comment) {
+  var createJSDocParamTag = deprecate(function createJSDocParamTag2(name, isBracketed, typeExpression, comment) {
     return factory.createJSDocParameterTag(void 0, name, isBracketed, typeExpression, false, comment ? factory.createNodeArray([factory.createJSDocText(comment)]) : void 0);
   }, factoryDeprecation);
-  var createComma = Debug.deprecate(function createComma2(left, right) {
+  var createComma = deprecate(function createComma2(left, right) {
     return factory.createComma(left, right);
   }, factoryDeprecation);
-  var createLessThan = Debug.deprecate(function createLessThan2(left, right) {
+  var createLessThan = deprecate(function createLessThan2(left, right) {
     return factory.createLessThan(left, right);
   }, factoryDeprecation);
-  var createAssignment = Debug.deprecate(function createAssignment2(left, right) {
+  var createAssignment = deprecate(function createAssignment2(left, right) {
     return factory.createAssignment(left, right);
   }, factoryDeprecation);
-  var createStrictEquality = Debug.deprecate(function createStrictEquality2(left, right) {
+  var createStrictEquality = deprecate(function createStrictEquality2(left, right) {
     return factory.createStrictEquality(left, right);
   }, factoryDeprecation);
-  var createStrictInequality = Debug.deprecate(function createStrictInequality2(left, right) {
+  var createStrictInequality = deprecate(function createStrictInequality2(left, right) {
     return factory.createStrictInequality(left, right);
   }, factoryDeprecation);
-  var createAdd = Debug.deprecate(function createAdd2(left, right) {
+  var createAdd = deprecate(function createAdd2(left, right) {
     return factory.createAdd(left, right);
   }, factoryDeprecation);
-  var createSubtract = Debug.deprecate(function createSubtract2(left, right) {
+  var createSubtract = deprecate(function createSubtract2(left, right) {
     return factory.createSubtract(left, right);
   }, factoryDeprecation);
-  var createLogicalAnd = Debug.deprecate(function createLogicalAnd2(left, right) {
+  var createLogicalAnd = deprecate(function createLogicalAnd2(left, right) {
     return factory.createLogicalAnd(left, right);
   }, factoryDeprecation);
-  var createLogicalOr = Debug.deprecate(function createLogicalOr2(left, right) {
+  var createLogicalOr = deprecate(function createLogicalOr2(left, right) {
     return factory.createLogicalOr(left, right);
   }, factoryDeprecation);
-  var createPostfixIncrement = Debug.deprecate(function createPostfixIncrement2(operand) {
+  var createPostfixIncrement = deprecate(function createPostfixIncrement2(operand) {
     return factory.createPostfixIncrement(operand);
   }, factoryDeprecation);
-  var createLogicalNot = Debug.deprecate(function createLogicalNot2(operand) {
+  var createLogicalNot = deprecate(function createLogicalNot2(operand) {
     return factory.createLogicalNot(operand);
   }, factoryDeprecation);
-  var createNode2 = Debug.deprecate(function createNode3(kind, pos = 0, end = 0) {
+  var createNode2 = deprecate(function createNode3(kind, pos = 0, end = 0) {
     return setTextRangePosEnd(
       kind === 308 /* SourceFile */ ? parseBaseNodeFactory.createBaseSourceFileNode(kind) : kind === 79 /* Identifier */ ? parseBaseNodeFactory.createBaseIdentifierNode(kind) : kind === 80 /* PrivateIdentifier */ ? parseBaseNodeFactory.createBasePrivateIdentifierNode(kind) : !isNodeKind(kind) ? parseBaseNodeFactory.createBaseTokenNode(kind) : parseBaseNodeFactory.createBaseNode(kind),
       pos,
       end
     );
   }, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory` method instead." });
-  var getMutableClone = Debug.deprecate(function getMutableClone2(node) {
+  var getMutableClone = deprecate(function getMutableClone2(node) {
     const clone2 = factory.cloneNode(node);
     setTextRange(clone2, node);
     setParent(clone2, node.parent);
@@ -150813,7 +150803,7 @@ ${options.prefix}` : "\n" : options.prefix
   }, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`." });
 
   // src/deprecatedCompat/4.0/renamedNodeTests.ts
-  var isTypeAssertion = Debug.deprecate(function isTypeAssertion2(node) {
+  var isTypeAssertion = deprecate(function isTypeAssertion2(node) {
     return node.kind === 213 /* TypeAssertionExpression */;
   }, {
     since: "4.0",
@@ -150822,7 +150812,7 @@ ${options.prefix}` : "\n" : options.prefix
   });
 
   // src/deprecatedCompat/4.2/renamedNodeTests.ts
-  var isIdentifierOrPrivateIdentifier = Debug.deprecate(function isIdentifierOrPrivateIdentifier2(node) {
+  var isIdentifierOrPrivateIdentifier = deprecate(function isIdentifierOrPrivateIdentifier2(node) {
     return isMemberName(node);
   }, {
     since: "4.2",
@@ -152528,6 +152518,7 @@ ${options.prefix}` : "\n" : options.prefix
       this.dirty = false;
       this.typingFiles = emptyArray2;
       this.moduleSpecifierCache = createModuleSpecifierCache(this);
+      this.createHash = maybeBind(this.projectService.host, this.projectService.host.createHash);
       this.globalCacheResolutionModuleName = ts_JsTyping_exports.nonRelativeModuleNameForTypingCache;
       this.projectName = projectName;
       this.directoryStructureHost = directoryStructureHost;
@@ -152856,15 +152847,14 @@ ${options.prefix}` : "\n" : options.prefix
         return [];
       }
       updateProjectIfDirty(this);
-      this.builderState = BuilderState.create(this.program, this.projectService.toCanonicalFileName, this.builderState, true);
+      this.builderState = BuilderState.create(this.program, this.builderState, true);
       return mapDefined(
         BuilderState.getFilesAffectedBy(
           this.builderState,
           this.program,
           scriptInfo.path,
           this.cancellationToken,
-          maybeBind(this.projectService.host, this.projectService.host.createHash),
-          this.getCanonicalFileName
+          this.projectService.host
         ),
         (sourceFile) => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : void 0
       );