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

package/lib/typescript.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20221115`;
+      version = `${versionMajorMinor}.0-dev.20221116`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -1789,15 +1789,9 @@ var ts = (() => {
         return LogLevel2;
       })(LogLevel || {});
       ((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;
         }
@@ -2313,52 +2307,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]" : "";
@@ -8112,10 +8060,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}'."),
@@ -17468,7 +17416,7 @@ ${lanes.join("\n")}
     const { isBracketed, typeExpression } = node;
     return isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* JSDocOptionalType */;
   }
-  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashAMDReferencePathRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, AccessKind, objectAllocator, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, extensionsToRemove, emptyFileSystemEntries;
+  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashAMDReferencePathRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, AccessKind, objectAllocator, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
       "use strict";
@@ -17618,6 +17566,7 @@ ${lanes.join("\n")}
       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 */]];
       allSupportedExtensionsWithJson = [...allSupportedExtensions, [".json" /* Json */]];
       supportedDeclarationExtensions = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */];
+      supportedTSImplementationExtensions = [".ts" /* Ts */, ".cts" /* Cts */, ".mts" /* Mts */, ".tsx" /* Tsx */];
       extensionsToRemove = [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".mts" /* Mts */, ".cjs" /* Cjs */, ".cts" /* Cts */, ".ts" /* Ts */, ".js" /* Js */, ".tsx" /* Tsx */, ".jsx" /* Jsx */, ".json" /* Json */];
       emptyFileSystemEntries = {
         files: emptyArray,
@@ -23193,7 +23142,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; }
             };`
       };
       asyncValues = {
@@ -34969,6 +34918,18 @@ ${lanes.join("\n")}
       return { path: r.path, ext: r.extension };
     }
   }
+  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;
@@ -35170,7 +35131,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;
@@ -35220,7 +35182,7 @@ ${lanes.join("\n")}
           }
           return resolvedTypeScriptOnly(
             loadNodeModuleFromDirectory(
-              4 /* DtsOnly */,
+              4 /* Declaration */,
               candidate,
               !directoryExists,
               moduleResolutionState
@@ -35241,11 +35203,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 {
@@ -35762,31 +35724,39 @@ ${lanes.join("\n")}
   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 = [];
@@ -35806,12 +35776,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,
@@ -35836,7 +35814,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);
         }
@@ -35877,7 +35855,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) {
@@ -35934,10 +35912,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);
@@ -35945,10 +35922,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) {
@@ -35958,7 +35934,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;
     }
@@ -35971,59 +35947,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);
@@ -36066,7 +36015,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"];
@@ -36154,7 +36103,8 @@ ${lanes.join("\n")}
       features: 0 /* None */,
       conditions: emptyArray,
       requestContainingDirectory: void 0,
-      reportDiagnostic: noop
+      reportDiagnostic: noop,
+      isConfigLookup: false
     };
   }
   function getPackageScopeForPath(fileName, state) {
@@ -36213,23 +36163,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) => {
@@ -36243,18 +36180,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) {
@@ -36277,19 +36214,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);
@@ -36451,7 +36376,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) {
@@ -36542,7 +36467,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) {
@@ -36579,10 +36504,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)));
                       }
@@ -36623,19 +36547,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");
@@ -36643,11 +36579,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)) {
@@ -36656,7 +36594,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) {
@@ -36796,9 +36734,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,
@@ -36825,7 +36764,7 @@ ${lanes.join("\n")}
         if (resolved2) {
           return resolved2;
         }
-        if (extensions === 0 /* TypeScript */) {
+        if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
           return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
         }
       } else {
@@ -36852,9 +36791,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,
@@ -36872,20 +36812,11 @@ ${lanes.join("\n")}
       trace(state.host, diagnostic, ...args);
     }
   }
-  var Extensions, typeScriptVersion, nodeModulesAtTypes, NodeResolutionFeatures, jsOnlyExtensions, tsExtensions, tsPlusJsonExtensions, tsconfigExtensions, nodeModulesPathPart, mangledScopedPackageSeparator;
+  var typeScriptVersion, nodeModulesAtTypes, NodeResolutionFeatures, nodeModulesPathPart, mangledScopedPackageSeparator;
   var init_moduleNameResolver = __esm({
     "src/compiler/moduleNameResolver.ts"() {
       "use strict";
       init_ts2();
-      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 || {});
       nodeModulesAtTypes = combinePaths("node_modules", "@types");
       NodeResolutionFeatures = /* @__PURE__ */ ((NodeResolutionFeatures2) => {
         NodeResolutionFeatures2[NodeResolutionFeatures2["None"] = 0] = "None";
@@ -36899,10 +36830,6 @@ ${lanes.join("\n")}
         NodeResolutionFeatures2[NodeResolutionFeatures2["EsmMode"] = 32] = "EsmMode";
         return NodeResolutionFeatures2;
       })(NodeResolutionFeatures || {});
-      jsOnlyExtensions = [1 /* JavaScript */];
-      tsExtensions = [0 /* TypeScript */, 1 /* JavaScript */];
-      tsPlusJsonExtensions = [...tsExtensions, 2 /* Json */];
-      tsconfigExtensions = [3 /* TSConfig */];
       nodeModulesPathPart = "/node_modules/";
       mangledScopedPackageSeparator = "__";
     }
@@ -39888,6 +39815,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);
@@ -39895,60 +39823,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;
@@ -76627,10 +76572,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) {
@@ -94939,7 +94884,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();
@@ -94947,7 +94892,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) {
@@ -95051,7 +94996,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)
@@ -95061,22 +95005,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(
@@ -95146,7 +95090,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;
@@ -95159,7 +95103,7 @@ ${lanes.join("\n")}
       getSourceFileFromReference: returnUndefined,
       redirectTargetsMap: createMultiMap(),
       getFileIncludeReasons: notImplemented,
-      createHash
+      createHash: maybeBind(host, host.createHash)
     };
     emitFiles(
       notImplementedResolver,
@@ -103354,7 +103298,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();
@@ -103362,6 +103306,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");
@@ -103400,30 +103345,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) {
@@ -103431,7 +103375,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;
@@ -103444,10 +103388,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) {
@@ -103586,7 +103530,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);
           }
@@ -103602,7 +103546,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));
               }
             }
@@ -103646,9 +103590,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;
@@ -103692,7 +103636,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();
           }
@@ -103752,10 +103696,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;
@@ -103767,7 +103712,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) {
@@ -103809,7 +103755,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;
@@ -103825,8 +103771,6 @@ ${lanes.join("\n")}
               state,
               affectedFile,
               cancellationToken,
-              computeHash,
-              getCanonicalFileName,
               host
             );
             return affectedFile;
@@ -103854,8 +103798,7 @@ ${lanes.join("\n")}
         program,
         nextKey.value,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName
+        host
       );
       state.currentChangedFilePath = nextKey.value;
       state.affectedFilesIndex = 0;
@@ -103907,7 +103850,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);
@@ -103916,8 +103859,7 @@ ${lanes.join("\n")}
         Debug.checkDefined(state.program),
         affectedFile,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName
+        host
       );
       return;
     }
@@ -103927,12 +103869,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);
@@ -103943,8 +103883,7 @@ ${lanes.join("\n")}
           program,
           sourceFile,
           cancellationToken,
-          computeHash,
-          getCanonicalFileName,
+          host,
           !host.disableUseFileVersionAsSignature
         );
         if (getEmitDeclarations(state.compilerOptions)) {
@@ -103966,7 +103905,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;
@@ -103974,14 +103913,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;
@@ -103995,9 +103932,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));
@@ -104007,7 +103944,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(
@@ -104017,28 +103954,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
       )
     );
@@ -104047,8 +103980,6 @@ ${lanes.join("\n")}
         state,
         referencingFilePath,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName,
         host
       )
     );
@@ -104077,9 +104008,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 = [];
@@ -104298,8 +104230,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) {
@@ -104307,7 +104240,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");
     }
@@ -104316,11 +104249,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();
@@ -104329,10 +104267,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;
@@ -104366,7 +104302,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) {
@@ -104440,10 +104376,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))
@@ -104487,7 +104423,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;
@@ -104543,7 +104479,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;
@@ -116412,6 +116348,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
@@ -146916,6 +146853,63 @@ ${options.prefix}` : "\n" : options.prefix
     }
   });
 
+  // src/deprecatedCompat/deprecate.ts
+  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);
+  }
+  var enableDeprecationWarnings, typeScriptVersion2;
+  var init_deprecate = __esm({
+    "src/deprecatedCompat/deprecate.ts"() {
+      "use strict";
+      init_ts5();
+      enableDeprecationWarnings = true;
+    }
+  });
+
   // src/deprecatedCompat/deprecations.ts
   function createOverload(name, overloads, binder2, deprecations) {
     Object.defineProperty(call, "name", { ...Object.getOwnPropertyDescriptor(call, "name"), value: name });
@@ -146923,7 +146917,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 });
         }
       }
     }
@@ -146964,6 +146958,7 @@ ${options.prefix}` : "\n" : options.prefix
     "src/deprecatedCompat/deprecations.ts"() {
       "use strict";
       init_ts5();
+      init_deprecate();
     }
   });
 
@@ -146973,337 +146968,338 @@ ${options.prefix}` : "\n" : options.prefix
     "src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts"() {
       "use strict";
       init_ts5();
+      init_deprecate();
       factoryDeprecation = { since: "4.0", warnAfter: "4.1", message: "Use the appropriate method on 'ts.factory' or the 'factory' supplied by your transformation context instead." };
-      createNodeArray = Debug.deprecate(factory.createNodeArray, factoryDeprecation);
-      createNumericLiteral = Debug.deprecate(factory.createNumericLiteral, factoryDeprecation);
-      createBigIntLiteral = Debug.deprecate(factory.createBigIntLiteral, factoryDeprecation);
-      createStringLiteral = Debug.deprecate(factory.createStringLiteral, factoryDeprecation);
-      createStringLiteralFromNode = Debug.deprecate(factory.createStringLiteralFromNode, factoryDeprecation);
-      createRegularExpressionLiteral = Debug.deprecate(factory.createRegularExpressionLiteral, factoryDeprecation);
-      createLoopVariable = Debug.deprecate(factory.createLoopVariable, factoryDeprecation);
-      createUniqueName = Debug.deprecate(factory.createUniqueName, factoryDeprecation);
-      createPrivateIdentifier = Debug.deprecate(factory.createPrivateIdentifier, factoryDeprecation);
-      createSuper = Debug.deprecate(factory.createSuper, factoryDeprecation);
-      createThis = Debug.deprecate(factory.createThis, factoryDeprecation);
-      createNull = Debug.deprecate(factory.createNull, factoryDeprecation);
-      createTrue = Debug.deprecate(factory.createTrue, factoryDeprecation);
-      createFalse = Debug.deprecate(factory.createFalse, factoryDeprecation);
-      createModifier = Debug.deprecate(factory.createModifier, factoryDeprecation);
-      createModifiersFromModifierFlags = Debug.deprecate(factory.createModifiersFromModifierFlags, factoryDeprecation);
-      createQualifiedName = Debug.deprecate(factory.createQualifiedName, factoryDeprecation);
-      updateQualifiedName = Debug.deprecate(factory.updateQualifiedName, factoryDeprecation);
-      createComputedPropertyName = Debug.deprecate(factory.createComputedPropertyName, factoryDeprecation);
-      updateComputedPropertyName = Debug.deprecate(factory.updateComputedPropertyName, factoryDeprecation);
-      createTypeParameterDeclaration = Debug.deprecate(factory.createTypeParameterDeclaration, factoryDeprecation);
-      updateTypeParameterDeclaration = Debug.deprecate(factory.updateTypeParameterDeclaration, factoryDeprecation);
-      createParameter = Debug.deprecate(factory.createParameterDeclaration, factoryDeprecation);
-      updateParameter = Debug.deprecate(factory.updateParameterDeclaration, factoryDeprecation);
-      createDecorator = Debug.deprecate(factory.createDecorator, factoryDeprecation);
-      updateDecorator = Debug.deprecate(factory.updateDecorator, factoryDeprecation);
-      createProperty = Debug.deprecate(factory.createPropertyDeclaration, factoryDeprecation);
-      updateProperty = Debug.deprecate(factory.updatePropertyDeclaration, factoryDeprecation);
-      createMethod = Debug.deprecate(factory.createMethodDeclaration, factoryDeprecation);
-      updateMethod = Debug.deprecate(factory.updateMethodDeclaration, factoryDeprecation);
-      createConstructor = Debug.deprecate(factory.createConstructorDeclaration, factoryDeprecation);
-      updateConstructor = Debug.deprecate(factory.updateConstructorDeclaration, factoryDeprecation);
-      createGetAccessor = Debug.deprecate(factory.createGetAccessorDeclaration, factoryDeprecation);
-      updateGetAccessor = Debug.deprecate(factory.updateGetAccessorDeclaration, factoryDeprecation);
-      createSetAccessor = Debug.deprecate(factory.createSetAccessorDeclaration, factoryDeprecation);
-      updateSetAccessor = Debug.deprecate(factory.updateSetAccessorDeclaration, factoryDeprecation);
-      createCallSignature = Debug.deprecate(factory.createCallSignature, factoryDeprecation);
-      updateCallSignature = Debug.deprecate(factory.updateCallSignature, factoryDeprecation);
-      createConstructSignature = Debug.deprecate(factory.createConstructSignature, factoryDeprecation);
-      updateConstructSignature = Debug.deprecate(factory.updateConstructSignature, factoryDeprecation);
-      updateIndexSignature = Debug.deprecate(factory.updateIndexSignature, factoryDeprecation);
-      createKeywordTypeNode = Debug.deprecate(factory.createKeywordTypeNode, factoryDeprecation);
-      createTypePredicateNodeWithModifier = Debug.deprecate(factory.createTypePredicateNode, factoryDeprecation);
-      updateTypePredicateNodeWithModifier = Debug.deprecate(factory.updateTypePredicateNode, factoryDeprecation);
-      createTypeReferenceNode = Debug.deprecate(factory.createTypeReferenceNode, factoryDeprecation);
-      updateTypeReferenceNode = Debug.deprecate(factory.updateTypeReferenceNode, factoryDeprecation);
-      createFunctionTypeNode = Debug.deprecate(factory.createFunctionTypeNode, factoryDeprecation);
-      updateFunctionTypeNode = Debug.deprecate(factory.updateFunctionTypeNode, factoryDeprecation);
-      createConstructorTypeNode = Debug.deprecate((typeParameters, parameters, type) => {
+      createNodeArray = deprecate(factory.createNodeArray, factoryDeprecation);
+      createNumericLiteral = deprecate(factory.createNumericLiteral, factoryDeprecation);
+      createBigIntLiteral = deprecate(factory.createBigIntLiteral, factoryDeprecation);
+      createStringLiteral = deprecate(factory.createStringLiteral, factoryDeprecation);
+      createStringLiteralFromNode = deprecate(factory.createStringLiteralFromNode, factoryDeprecation);
+      createRegularExpressionLiteral = deprecate(factory.createRegularExpressionLiteral, factoryDeprecation);
+      createLoopVariable = deprecate(factory.createLoopVariable, factoryDeprecation);
+      createUniqueName = deprecate(factory.createUniqueName, factoryDeprecation);
+      createPrivateIdentifier = deprecate(factory.createPrivateIdentifier, factoryDeprecation);
+      createSuper = deprecate(factory.createSuper, factoryDeprecation);
+      createThis = deprecate(factory.createThis, factoryDeprecation);
+      createNull = deprecate(factory.createNull, factoryDeprecation);
+      createTrue = deprecate(factory.createTrue, factoryDeprecation);
+      createFalse = deprecate(factory.createFalse, factoryDeprecation);
+      createModifier = deprecate(factory.createModifier, factoryDeprecation);
+      createModifiersFromModifierFlags = deprecate(factory.createModifiersFromModifierFlags, factoryDeprecation);
+      createQualifiedName = deprecate(factory.createQualifiedName, factoryDeprecation);
+      updateQualifiedName = deprecate(factory.updateQualifiedName, factoryDeprecation);
+      createComputedPropertyName = deprecate(factory.createComputedPropertyName, factoryDeprecation);
+      updateComputedPropertyName = deprecate(factory.updateComputedPropertyName, factoryDeprecation);
+      createTypeParameterDeclaration = deprecate(factory.createTypeParameterDeclaration, factoryDeprecation);
+      updateTypeParameterDeclaration = deprecate(factory.updateTypeParameterDeclaration, factoryDeprecation);
+      createParameter = deprecate(factory.createParameterDeclaration, factoryDeprecation);
+      updateParameter = deprecate(factory.updateParameterDeclaration, factoryDeprecation);
+      createDecorator = deprecate(factory.createDecorator, factoryDeprecation);
+      updateDecorator = deprecate(factory.updateDecorator, factoryDeprecation);
+      createProperty = deprecate(factory.createPropertyDeclaration, factoryDeprecation);
+      updateProperty = deprecate(factory.updatePropertyDeclaration, factoryDeprecation);
+      createMethod = deprecate(factory.createMethodDeclaration, factoryDeprecation);
+      updateMethod = deprecate(factory.updateMethodDeclaration, factoryDeprecation);
+      createConstructor = deprecate(factory.createConstructorDeclaration, factoryDeprecation);
+      updateConstructor = deprecate(factory.updateConstructorDeclaration, factoryDeprecation);
+      createGetAccessor = deprecate(factory.createGetAccessorDeclaration, factoryDeprecation);
+      updateGetAccessor = deprecate(factory.updateGetAccessorDeclaration, factoryDeprecation);
+      createSetAccessor = deprecate(factory.createSetAccessorDeclaration, factoryDeprecation);
+      updateSetAccessor = deprecate(factory.updateSetAccessorDeclaration, factoryDeprecation);
+      createCallSignature = deprecate(factory.createCallSignature, factoryDeprecation);
+      updateCallSignature = deprecate(factory.updateCallSignature, factoryDeprecation);
+      createConstructSignature = deprecate(factory.createConstructSignature, factoryDeprecation);
+      updateConstructSignature = deprecate(factory.updateConstructSignature, factoryDeprecation);
+      updateIndexSignature = deprecate(factory.updateIndexSignature, factoryDeprecation);
+      createKeywordTypeNode = deprecate(factory.createKeywordTypeNode, factoryDeprecation);
+      createTypePredicateNodeWithModifier = deprecate(factory.createTypePredicateNode, factoryDeprecation);
+      updateTypePredicateNodeWithModifier = deprecate(factory.updateTypePredicateNode, factoryDeprecation);
+      createTypeReferenceNode = deprecate(factory.createTypeReferenceNode, factoryDeprecation);
+      updateTypeReferenceNode = deprecate(factory.updateTypeReferenceNode, factoryDeprecation);
+      createFunctionTypeNode = deprecate(factory.createFunctionTypeNode, factoryDeprecation);
+      updateFunctionTypeNode = deprecate(factory.updateFunctionTypeNode, factoryDeprecation);
+      createConstructorTypeNode = deprecate((typeParameters, parameters, type) => {
         return factory.createConstructorTypeNode(void 0, typeParameters, parameters, type);
       }, factoryDeprecation);
-      updateConstructorTypeNode = Debug.deprecate((node, typeParameters, parameters, type) => {
+      updateConstructorTypeNode = deprecate((node, typeParameters, parameters, type) => {
         return factory.updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type);
       }, factoryDeprecation);
-      createTypeQueryNode = Debug.deprecate(factory.createTypeQueryNode, factoryDeprecation);
-      updateTypeQueryNode = Debug.deprecate(factory.updateTypeQueryNode, factoryDeprecation);
-      createTypeLiteralNode = Debug.deprecate(factory.createTypeLiteralNode, factoryDeprecation);
-      updateTypeLiteralNode = Debug.deprecate(factory.updateTypeLiteralNode, factoryDeprecation);
-      createArrayTypeNode = Debug.deprecate(factory.createArrayTypeNode, factoryDeprecation);
-      updateArrayTypeNode = Debug.deprecate(factory.updateArrayTypeNode, factoryDeprecation);
-      createTupleTypeNode = Debug.deprecate(factory.createTupleTypeNode, factoryDeprecation);
-      updateTupleTypeNode = Debug.deprecate(factory.updateTupleTypeNode, factoryDeprecation);
-      createOptionalTypeNode = Debug.deprecate(factory.createOptionalTypeNode, factoryDeprecation);
-      updateOptionalTypeNode = Debug.deprecate(factory.updateOptionalTypeNode, factoryDeprecation);
-      createRestTypeNode = Debug.deprecate(factory.createRestTypeNode, factoryDeprecation);
-      updateRestTypeNode = Debug.deprecate(factory.updateRestTypeNode, factoryDeprecation);
-      createUnionTypeNode = Debug.deprecate(factory.createUnionTypeNode, factoryDeprecation);
-      updateUnionTypeNode = Debug.deprecate(factory.updateUnionTypeNode, factoryDeprecation);
-      createIntersectionTypeNode = Debug.deprecate(factory.createIntersectionTypeNode, factoryDeprecation);
-      updateIntersectionTypeNode = Debug.deprecate(factory.updateIntersectionTypeNode, factoryDeprecation);
-      createConditionalTypeNode = Debug.deprecate(factory.createConditionalTypeNode, factoryDeprecation);
-      updateConditionalTypeNode = Debug.deprecate(factory.updateConditionalTypeNode, factoryDeprecation);
-      createInferTypeNode = Debug.deprecate(factory.createInferTypeNode, factoryDeprecation);
-      updateInferTypeNode = Debug.deprecate(factory.updateInferTypeNode, factoryDeprecation);
-      createImportTypeNode = Debug.deprecate(factory.createImportTypeNode, factoryDeprecation);
-      updateImportTypeNode = Debug.deprecate(factory.updateImportTypeNode, factoryDeprecation);
-      createParenthesizedType = Debug.deprecate(factory.createParenthesizedType, factoryDeprecation);
-      updateParenthesizedType = Debug.deprecate(factory.updateParenthesizedType, factoryDeprecation);
-      createThisTypeNode = Debug.deprecate(factory.createThisTypeNode, factoryDeprecation);
-      updateTypeOperatorNode = Debug.deprecate(factory.updateTypeOperatorNode, factoryDeprecation);
-      createIndexedAccessTypeNode = Debug.deprecate(factory.createIndexedAccessTypeNode, factoryDeprecation);
-      updateIndexedAccessTypeNode = Debug.deprecate(factory.updateIndexedAccessTypeNode, factoryDeprecation);
-      createMappedTypeNode = Debug.deprecate(factory.createMappedTypeNode, factoryDeprecation);
-      updateMappedTypeNode = Debug.deprecate(factory.updateMappedTypeNode, factoryDeprecation);
-      createLiteralTypeNode = Debug.deprecate(factory.createLiteralTypeNode, factoryDeprecation);
-      updateLiteralTypeNode = Debug.deprecate(factory.updateLiteralTypeNode, factoryDeprecation);
-      createObjectBindingPattern = Debug.deprecate(factory.createObjectBindingPattern, factoryDeprecation);
-      updateObjectBindingPattern = Debug.deprecate(factory.updateObjectBindingPattern, factoryDeprecation);
-      createArrayBindingPattern = Debug.deprecate(factory.createArrayBindingPattern, factoryDeprecation);
-      updateArrayBindingPattern = Debug.deprecate(factory.updateArrayBindingPattern, factoryDeprecation);
-      createBindingElement = Debug.deprecate(factory.createBindingElement, factoryDeprecation);
-      updateBindingElement = Debug.deprecate(factory.updateBindingElement, factoryDeprecation);
-      createArrayLiteral = Debug.deprecate(factory.createArrayLiteralExpression, factoryDeprecation);
-      updateArrayLiteral = Debug.deprecate(factory.updateArrayLiteralExpression, factoryDeprecation);
-      createObjectLiteral = Debug.deprecate(factory.createObjectLiteralExpression, factoryDeprecation);
-      updateObjectLiteral = Debug.deprecate(factory.updateObjectLiteralExpression, factoryDeprecation);
-      createPropertyAccess = Debug.deprecate(factory.createPropertyAccessExpression, factoryDeprecation);
-      updatePropertyAccess = Debug.deprecate(factory.updatePropertyAccessExpression, factoryDeprecation);
-      createPropertyAccessChain = Debug.deprecate(factory.createPropertyAccessChain, factoryDeprecation);
-      updatePropertyAccessChain = Debug.deprecate(factory.updatePropertyAccessChain, factoryDeprecation);
-      createElementAccess = Debug.deprecate(factory.createElementAccessExpression, factoryDeprecation);
-      updateElementAccess = Debug.deprecate(factory.updateElementAccessExpression, factoryDeprecation);
-      createElementAccessChain = Debug.deprecate(factory.createElementAccessChain, factoryDeprecation);
-      updateElementAccessChain = Debug.deprecate(factory.updateElementAccessChain, factoryDeprecation);
-      createCall = Debug.deprecate(factory.createCallExpression, factoryDeprecation);
-      updateCall = Debug.deprecate(factory.updateCallExpression, factoryDeprecation);
-      createCallChain = Debug.deprecate(factory.createCallChain, factoryDeprecation);
-      updateCallChain = Debug.deprecate(factory.updateCallChain, factoryDeprecation);
-      createNew = Debug.deprecate(factory.createNewExpression, factoryDeprecation);
-      updateNew = Debug.deprecate(factory.updateNewExpression, factoryDeprecation);
-      createTypeAssertion = Debug.deprecate(factory.createTypeAssertion, factoryDeprecation);
-      updateTypeAssertion = Debug.deprecate(factory.updateTypeAssertion, factoryDeprecation);
-      createParen = Debug.deprecate(factory.createParenthesizedExpression, factoryDeprecation);
-      updateParen = Debug.deprecate(factory.updateParenthesizedExpression, factoryDeprecation);
-      createFunctionExpression = Debug.deprecate(factory.createFunctionExpression, factoryDeprecation);
-      updateFunctionExpression = Debug.deprecate(factory.updateFunctionExpression, factoryDeprecation);
-      createDelete = Debug.deprecate(factory.createDeleteExpression, factoryDeprecation);
-      updateDelete = Debug.deprecate(factory.updateDeleteExpression, factoryDeprecation);
-      createTypeOf = Debug.deprecate(factory.createTypeOfExpression, factoryDeprecation);
-      updateTypeOf = Debug.deprecate(factory.updateTypeOfExpression, factoryDeprecation);
-      createVoid = Debug.deprecate(factory.createVoidExpression, factoryDeprecation);
-      updateVoid = Debug.deprecate(factory.updateVoidExpression, factoryDeprecation);
-      createAwait = Debug.deprecate(factory.createAwaitExpression, factoryDeprecation);
-      updateAwait = Debug.deprecate(factory.updateAwaitExpression, factoryDeprecation);
-      createPrefix = Debug.deprecate(factory.createPrefixUnaryExpression, factoryDeprecation);
-      updatePrefix = Debug.deprecate(factory.updatePrefixUnaryExpression, factoryDeprecation);
-      createPostfix = Debug.deprecate(factory.createPostfixUnaryExpression, factoryDeprecation);
-      updatePostfix = Debug.deprecate(factory.updatePostfixUnaryExpression, factoryDeprecation);
-      createBinary = Debug.deprecate(factory.createBinaryExpression, factoryDeprecation);
-      updateConditional = Debug.deprecate(factory.updateConditionalExpression, factoryDeprecation);
-      createTemplateExpression = Debug.deprecate(factory.createTemplateExpression, factoryDeprecation);
-      updateTemplateExpression = Debug.deprecate(factory.updateTemplateExpression, factoryDeprecation);
-      createTemplateHead = Debug.deprecate(factory.createTemplateHead, factoryDeprecation);
-      createTemplateMiddle = Debug.deprecate(factory.createTemplateMiddle, factoryDeprecation);
-      createTemplateTail = Debug.deprecate(factory.createTemplateTail, factoryDeprecation);
-      createNoSubstitutionTemplateLiteral = Debug.deprecate(factory.createNoSubstitutionTemplateLiteral, factoryDeprecation);
-      updateYield = Debug.deprecate(factory.updateYieldExpression, factoryDeprecation);
-      createSpread = Debug.deprecate(factory.createSpreadElement, factoryDeprecation);
-      updateSpread = Debug.deprecate(factory.updateSpreadElement, factoryDeprecation);
-      createOmittedExpression = Debug.deprecate(factory.createOmittedExpression, factoryDeprecation);
-      createAsExpression = Debug.deprecate(factory.createAsExpression, factoryDeprecation);
-      updateAsExpression = Debug.deprecate(factory.updateAsExpression, factoryDeprecation);
-      createNonNullExpression = Debug.deprecate(factory.createNonNullExpression, factoryDeprecation);
-      updateNonNullExpression = Debug.deprecate(factory.updateNonNullExpression, factoryDeprecation);
-      createNonNullChain = Debug.deprecate(factory.createNonNullChain, factoryDeprecation);
-      updateNonNullChain = Debug.deprecate(factory.updateNonNullChain, factoryDeprecation);
-      createMetaProperty = Debug.deprecate(factory.createMetaProperty, factoryDeprecation);
-      updateMetaProperty = Debug.deprecate(factory.updateMetaProperty, factoryDeprecation);
-      createTemplateSpan = Debug.deprecate(factory.createTemplateSpan, factoryDeprecation);
-      updateTemplateSpan = Debug.deprecate(factory.updateTemplateSpan, factoryDeprecation);
-      createSemicolonClassElement = Debug.deprecate(factory.createSemicolonClassElement, factoryDeprecation);
-      createBlock = Debug.deprecate(factory.createBlock, factoryDeprecation);
-      updateBlock = Debug.deprecate(factory.updateBlock, factoryDeprecation);
-      createVariableStatement = Debug.deprecate(factory.createVariableStatement, factoryDeprecation);
-      updateVariableStatement = Debug.deprecate(factory.updateVariableStatement, factoryDeprecation);
-      createEmptyStatement = Debug.deprecate(factory.createEmptyStatement, factoryDeprecation);
-      createExpressionStatement = Debug.deprecate(factory.createExpressionStatement, factoryDeprecation);
-      updateExpressionStatement = Debug.deprecate(factory.updateExpressionStatement, factoryDeprecation);
-      createStatement = Debug.deprecate(factory.createExpressionStatement, factoryDeprecation);
-      updateStatement = Debug.deprecate(factory.updateExpressionStatement, factoryDeprecation);
-      createIf = Debug.deprecate(factory.createIfStatement, factoryDeprecation);
-      updateIf = Debug.deprecate(factory.updateIfStatement, factoryDeprecation);
-      createDo = Debug.deprecate(factory.createDoStatement, factoryDeprecation);
-      updateDo = Debug.deprecate(factory.updateDoStatement, factoryDeprecation);
-      createWhile = Debug.deprecate(factory.createWhileStatement, factoryDeprecation);
-      updateWhile = Debug.deprecate(factory.updateWhileStatement, factoryDeprecation);
-      createFor = Debug.deprecate(factory.createForStatement, factoryDeprecation);
-      updateFor = Debug.deprecate(factory.updateForStatement, factoryDeprecation);
-      createForIn = Debug.deprecate(factory.createForInStatement, factoryDeprecation);
-      updateForIn = Debug.deprecate(factory.updateForInStatement, factoryDeprecation);
-      createForOf = Debug.deprecate(factory.createForOfStatement, factoryDeprecation);
-      updateForOf = Debug.deprecate(factory.updateForOfStatement, factoryDeprecation);
-      createContinue = Debug.deprecate(factory.createContinueStatement, factoryDeprecation);
-      updateContinue = Debug.deprecate(factory.updateContinueStatement, factoryDeprecation);
-      createBreak = Debug.deprecate(factory.createBreakStatement, factoryDeprecation);
-      updateBreak = Debug.deprecate(factory.updateBreakStatement, factoryDeprecation);
-      createReturn = Debug.deprecate(factory.createReturnStatement, factoryDeprecation);
-      updateReturn = Debug.deprecate(factory.updateReturnStatement, factoryDeprecation);
-      createWith = Debug.deprecate(factory.createWithStatement, factoryDeprecation);
-      updateWith = Debug.deprecate(factory.updateWithStatement, factoryDeprecation);
-      createSwitch = Debug.deprecate(factory.createSwitchStatement, factoryDeprecation);
-      updateSwitch = Debug.deprecate(factory.updateSwitchStatement, factoryDeprecation);
-      createLabel = Debug.deprecate(factory.createLabeledStatement, factoryDeprecation);
-      updateLabel = Debug.deprecate(factory.updateLabeledStatement, factoryDeprecation);
-      createThrow = Debug.deprecate(factory.createThrowStatement, factoryDeprecation);
-      updateThrow = Debug.deprecate(factory.updateThrowStatement, factoryDeprecation);
-      createTry = Debug.deprecate(factory.createTryStatement, factoryDeprecation);
-      updateTry = Debug.deprecate(factory.updateTryStatement, factoryDeprecation);
-      createDebuggerStatement = Debug.deprecate(factory.createDebuggerStatement, factoryDeprecation);
-      createVariableDeclarationList = Debug.deprecate(factory.createVariableDeclarationList, factoryDeprecation);
-      updateVariableDeclarationList = Debug.deprecate(factory.updateVariableDeclarationList, factoryDeprecation);
-      createFunctionDeclaration = Debug.deprecate(factory.createFunctionDeclaration, factoryDeprecation);
-      updateFunctionDeclaration = Debug.deprecate(factory.updateFunctionDeclaration, factoryDeprecation);
-      createClassDeclaration = Debug.deprecate(factory.createClassDeclaration, factoryDeprecation);
-      updateClassDeclaration = Debug.deprecate(factory.updateClassDeclaration, factoryDeprecation);
-      createInterfaceDeclaration = Debug.deprecate(factory.createInterfaceDeclaration, factoryDeprecation);
-      updateInterfaceDeclaration = Debug.deprecate(factory.updateInterfaceDeclaration, factoryDeprecation);
-      createTypeAliasDeclaration = Debug.deprecate(factory.createTypeAliasDeclaration, factoryDeprecation);
-      updateTypeAliasDeclaration = Debug.deprecate(factory.updateTypeAliasDeclaration, factoryDeprecation);
-      createEnumDeclaration = Debug.deprecate(factory.createEnumDeclaration, factoryDeprecation);
-      updateEnumDeclaration = Debug.deprecate(factory.updateEnumDeclaration, factoryDeprecation);
-      createModuleDeclaration = Debug.deprecate(factory.createModuleDeclaration, factoryDeprecation);
-      updateModuleDeclaration = Debug.deprecate(factory.updateModuleDeclaration, factoryDeprecation);
-      createModuleBlock = Debug.deprecate(factory.createModuleBlock, factoryDeprecation);
-      updateModuleBlock = Debug.deprecate(factory.updateModuleBlock, factoryDeprecation);
-      createCaseBlock = Debug.deprecate(factory.createCaseBlock, factoryDeprecation);
-      updateCaseBlock = Debug.deprecate(factory.updateCaseBlock, factoryDeprecation);
-      createNamespaceExportDeclaration = Debug.deprecate(factory.createNamespaceExportDeclaration, factoryDeprecation);
-      updateNamespaceExportDeclaration = Debug.deprecate(factory.updateNamespaceExportDeclaration, factoryDeprecation);
-      createImportEqualsDeclaration = Debug.deprecate(factory.createImportEqualsDeclaration, factoryDeprecation);
-      updateImportEqualsDeclaration = Debug.deprecate(factory.updateImportEqualsDeclaration, factoryDeprecation);
-      createImportDeclaration = Debug.deprecate(factory.createImportDeclaration, factoryDeprecation);
-      updateImportDeclaration = Debug.deprecate(factory.updateImportDeclaration, factoryDeprecation);
-      createNamespaceImport = Debug.deprecate(factory.createNamespaceImport, factoryDeprecation);
-      updateNamespaceImport = Debug.deprecate(factory.updateNamespaceImport, factoryDeprecation);
-      createNamedImports = Debug.deprecate(factory.createNamedImports, factoryDeprecation);
-      updateNamedImports = Debug.deprecate(factory.updateNamedImports, factoryDeprecation);
-      createImportSpecifier = Debug.deprecate(factory.createImportSpecifier, factoryDeprecation);
-      updateImportSpecifier = Debug.deprecate(factory.updateImportSpecifier, factoryDeprecation);
-      createExportAssignment2 = Debug.deprecate(factory.createExportAssignment, factoryDeprecation);
-      updateExportAssignment = Debug.deprecate(factory.updateExportAssignment, factoryDeprecation);
-      createNamedExports = Debug.deprecate(factory.createNamedExports, factoryDeprecation);
-      updateNamedExports = Debug.deprecate(factory.updateNamedExports, factoryDeprecation);
-      createExportSpecifier = Debug.deprecate(factory.createExportSpecifier, factoryDeprecation);
-      updateExportSpecifier = Debug.deprecate(factory.updateExportSpecifier, factoryDeprecation);
-      createExternalModuleReference = Debug.deprecate(factory.createExternalModuleReference, factoryDeprecation);
-      updateExternalModuleReference = Debug.deprecate(factory.updateExternalModuleReference, factoryDeprecation);
-      createJSDocTypeExpression = Debug.deprecate(factory.createJSDocTypeExpression, factoryDeprecation);
-      createJSDocTypeTag = Debug.deprecate(factory.createJSDocTypeTag, factoryDeprecation);
-      createJSDocReturnTag = Debug.deprecate(factory.createJSDocReturnTag, factoryDeprecation);
-      createJSDocThisTag = Debug.deprecate(factory.createJSDocThisTag, factoryDeprecation);
-      createJSDocComment = Debug.deprecate(factory.createJSDocComment, factoryDeprecation);
-      createJSDocParameterTag = Debug.deprecate(factory.createJSDocParameterTag, factoryDeprecation);
-      createJSDocClassTag = Debug.deprecate(factory.createJSDocClassTag, factoryDeprecation);
-      createJSDocAugmentsTag = Debug.deprecate(factory.createJSDocAugmentsTag, factoryDeprecation);
-      createJSDocEnumTag = Debug.deprecate(factory.createJSDocEnumTag, factoryDeprecation);
-      createJSDocTemplateTag = Debug.deprecate(factory.createJSDocTemplateTag, factoryDeprecation);
-      createJSDocTypedefTag = Debug.deprecate(factory.createJSDocTypedefTag, factoryDeprecation);
-      createJSDocCallbackTag = Debug.deprecate(factory.createJSDocCallbackTag, factoryDeprecation);
-      createJSDocSignature = Debug.deprecate(factory.createJSDocSignature, factoryDeprecation);
-      createJSDocPropertyTag = Debug.deprecate(factory.createJSDocPropertyTag, factoryDeprecation);
-      createJSDocTypeLiteral = Debug.deprecate(factory.createJSDocTypeLiteral, factoryDeprecation);
-      createJSDocImplementsTag = Debug.deprecate(factory.createJSDocImplementsTag, factoryDeprecation);
-      createJSDocAuthorTag = Debug.deprecate(factory.createJSDocAuthorTag, factoryDeprecation);
-      createJSDocPublicTag = Debug.deprecate(factory.createJSDocPublicTag, factoryDeprecation);
-      createJSDocPrivateTag = Debug.deprecate(factory.createJSDocPrivateTag, factoryDeprecation);
-      createJSDocProtectedTag = Debug.deprecate(factory.createJSDocProtectedTag, factoryDeprecation);
-      createJSDocReadonlyTag = Debug.deprecate(factory.createJSDocReadonlyTag, factoryDeprecation);
-      createJSDocTag = Debug.deprecate(factory.createJSDocUnknownTag, factoryDeprecation);
-      createJsxElement = Debug.deprecate(factory.createJsxElement, factoryDeprecation);
-      updateJsxElement = Debug.deprecate(factory.updateJsxElement, factoryDeprecation);
-      createJsxSelfClosingElement = Debug.deprecate(factory.createJsxSelfClosingElement, factoryDeprecation);
-      updateJsxSelfClosingElement = Debug.deprecate(factory.updateJsxSelfClosingElement, factoryDeprecation);
-      createJsxOpeningElement = Debug.deprecate(factory.createJsxOpeningElement, factoryDeprecation);
-      updateJsxOpeningElement = Debug.deprecate(factory.updateJsxOpeningElement, factoryDeprecation);
-      createJsxClosingElement = Debug.deprecate(factory.createJsxClosingElement, factoryDeprecation);
-      updateJsxClosingElement = Debug.deprecate(factory.updateJsxClosingElement, factoryDeprecation);
-      createJsxFragment = Debug.deprecate(factory.createJsxFragment, factoryDeprecation);
-      createJsxText = Debug.deprecate(factory.createJsxText, factoryDeprecation);
-      updateJsxText = Debug.deprecate(factory.updateJsxText, factoryDeprecation);
-      createJsxOpeningFragment = Debug.deprecate(factory.createJsxOpeningFragment, factoryDeprecation);
-      createJsxJsxClosingFragment = Debug.deprecate(factory.createJsxJsxClosingFragment, factoryDeprecation);
-      updateJsxFragment = Debug.deprecate(factory.updateJsxFragment, factoryDeprecation);
-      createJsxAttribute = Debug.deprecate(factory.createJsxAttribute, factoryDeprecation);
-      updateJsxAttribute = Debug.deprecate(factory.updateJsxAttribute, factoryDeprecation);
-      createJsxAttributes = Debug.deprecate(factory.createJsxAttributes, factoryDeprecation);
-      updateJsxAttributes = Debug.deprecate(factory.updateJsxAttributes, factoryDeprecation);
-      createJsxSpreadAttribute = Debug.deprecate(factory.createJsxSpreadAttribute, factoryDeprecation);
-      updateJsxSpreadAttribute = Debug.deprecate(factory.updateJsxSpreadAttribute, factoryDeprecation);
-      createJsxExpression = Debug.deprecate(factory.createJsxExpression, factoryDeprecation);
-      updateJsxExpression = Debug.deprecate(factory.updateJsxExpression, factoryDeprecation);
-      createCaseClause = Debug.deprecate(factory.createCaseClause, factoryDeprecation);
-      updateCaseClause = Debug.deprecate(factory.updateCaseClause, factoryDeprecation);
-      createDefaultClause = Debug.deprecate(factory.createDefaultClause, factoryDeprecation);
-      updateDefaultClause = Debug.deprecate(factory.updateDefaultClause, factoryDeprecation);
-      createHeritageClause = Debug.deprecate(factory.createHeritageClause, factoryDeprecation);
-      updateHeritageClause = Debug.deprecate(factory.updateHeritageClause, factoryDeprecation);
-      createCatchClause = Debug.deprecate(factory.createCatchClause, factoryDeprecation);
-      updateCatchClause = Debug.deprecate(factory.updateCatchClause, factoryDeprecation);
-      createPropertyAssignment = Debug.deprecate(factory.createPropertyAssignment, factoryDeprecation);
-      updatePropertyAssignment = Debug.deprecate(factory.updatePropertyAssignment, factoryDeprecation);
-      createShorthandPropertyAssignment = Debug.deprecate(factory.createShorthandPropertyAssignment, factoryDeprecation);
-      updateShorthandPropertyAssignment = Debug.deprecate(factory.updateShorthandPropertyAssignment, factoryDeprecation);
-      createSpreadAssignment = Debug.deprecate(factory.createSpreadAssignment, factoryDeprecation);
-      updateSpreadAssignment = Debug.deprecate(factory.updateSpreadAssignment, factoryDeprecation);
-      createEnumMember = Debug.deprecate(factory.createEnumMember, factoryDeprecation);
-      updateEnumMember = Debug.deprecate(factory.updateEnumMember, factoryDeprecation);
-      updateSourceFileNode = Debug.deprecate(factory.updateSourceFile, factoryDeprecation);
-      createNotEmittedStatement = Debug.deprecate(factory.createNotEmittedStatement, factoryDeprecation);
-      createPartiallyEmittedExpression = Debug.deprecate(factory.createPartiallyEmittedExpression, factoryDeprecation);
-      updatePartiallyEmittedExpression = Debug.deprecate(factory.updatePartiallyEmittedExpression, factoryDeprecation);
-      createCommaList = Debug.deprecate(factory.createCommaListExpression, factoryDeprecation);
-      updateCommaList = Debug.deprecate(factory.updateCommaListExpression, factoryDeprecation);
-      createBundle = Debug.deprecate(factory.createBundle, factoryDeprecation);
-      updateBundle = Debug.deprecate(factory.updateBundle, factoryDeprecation);
-      createImmediatelyInvokedFunctionExpression = Debug.deprecate(factory.createImmediatelyInvokedFunctionExpression, factoryDeprecation);
-      createImmediatelyInvokedArrowFunction = Debug.deprecate(factory.createImmediatelyInvokedArrowFunction, factoryDeprecation);
-      createVoidZero = Debug.deprecate(factory.createVoidZero, factoryDeprecation);
-      createExportDefault = Debug.deprecate(factory.createExportDefault, factoryDeprecation);
-      createExternalModuleExport = Debug.deprecate(factory.createExternalModuleExport, factoryDeprecation);
-      createNamespaceExport = Debug.deprecate(factory.createNamespaceExport, factoryDeprecation);
-      updateNamespaceExport = Debug.deprecate(factory.updateNamespaceExport, factoryDeprecation);
-      createToken = Debug.deprecate(function createToken2(kind) {
+      createTypeQueryNode = deprecate(factory.createTypeQueryNode, factoryDeprecation);
+      updateTypeQueryNode = deprecate(factory.updateTypeQueryNode, factoryDeprecation);
+      createTypeLiteralNode = deprecate(factory.createTypeLiteralNode, factoryDeprecation);
+      updateTypeLiteralNode = deprecate(factory.updateTypeLiteralNode, factoryDeprecation);
+      createArrayTypeNode = deprecate(factory.createArrayTypeNode, factoryDeprecation);
+      updateArrayTypeNode = deprecate(factory.updateArrayTypeNode, factoryDeprecation);
+      createTupleTypeNode = deprecate(factory.createTupleTypeNode, factoryDeprecation);
+      updateTupleTypeNode = deprecate(factory.updateTupleTypeNode, factoryDeprecation);
+      createOptionalTypeNode = deprecate(factory.createOptionalTypeNode, factoryDeprecation);
+      updateOptionalTypeNode = deprecate(factory.updateOptionalTypeNode, factoryDeprecation);
+      createRestTypeNode = deprecate(factory.createRestTypeNode, factoryDeprecation);
+      updateRestTypeNode = deprecate(factory.updateRestTypeNode, factoryDeprecation);
+      createUnionTypeNode = deprecate(factory.createUnionTypeNode, factoryDeprecation);
+      updateUnionTypeNode = deprecate(factory.updateUnionTypeNode, factoryDeprecation);
+      createIntersectionTypeNode = deprecate(factory.createIntersectionTypeNode, factoryDeprecation);
+      updateIntersectionTypeNode = deprecate(factory.updateIntersectionTypeNode, factoryDeprecation);
+      createConditionalTypeNode = deprecate(factory.createConditionalTypeNode, factoryDeprecation);
+      updateConditionalTypeNode = deprecate(factory.updateConditionalTypeNode, factoryDeprecation);
+      createInferTypeNode = deprecate(factory.createInferTypeNode, factoryDeprecation);
+      updateInferTypeNode = deprecate(factory.updateInferTypeNode, factoryDeprecation);
+      createImportTypeNode = deprecate(factory.createImportTypeNode, factoryDeprecation);
+      updateImportTypeNode = deprecate(factory.updateImportTypeNode, factoryDeprecation);
+      createParenthesizedType = deprecate(factory.createParenthesizedType, factoryDeprecation);
+      updateParenthesizedType = deprecate(factory.updateParenthesizedType, factoryDeprecation);
+      createThisTypeNode = deprecate(factory.createThisTypeNode, factoryDeprecation);
+      updateTypeOperatorNode = deprecate(factory.updateTypeOperatorNode, factoryDeprecation);
+      createIndexedAccessTypeNode = deprecate(factory.createIndexedAccessTypeNode, factoryDeprecation);
+      updateIndexedAccessTypeNode = deprecate(factory.updateIndexedAccessTypeNode, factoryDeprecation);
+      createMappedTypeNode = deprecate(factory.createMappedTypeNode, factoryDeprecation);
+      updateMappedTypeNode = deprecate(factory.updateMappedTypeNode, factoryDeprecation);
+      createLiteralTypeNode = deprecate(factory.createLiteralTypeNode, factoryDeprecation);
+      updateLiteralTypeNode = deprecate(factory.updateLiteralTypeNode, factoryDeprecation);
+      createObjectBindingPattern = deprecate(factory.createObjectBindingPattern, factoryDeprecation);
+      updateObjectBindingPattern = deprecate(factory.updateObjectBindingPattern, factoryDeprecation);
+      createArrayBindingPattern = deprecate(factory.createArrayBindingPattern, factoryDeprecation);
+      updateArrayBindingPattern = deprecate(factory.updateArrayBindingPattern, factoryDeprecation);
+      createBindingElement = deprecate(factory.createBindingElement, factoryDeprecation);
+      updateBindingElement = deprecate(factory.updateBindingElement, factoryDeprecation);
+      createArrayLiteral = deprecate(factory.createArrayLiteralExpression, factoryDeprecation);
+      updateArrayLiteral = deprecate(factory.updateArrayLiteralExpression, factoryDeprecation);
+      createObjectLiteral = deprecate(factory.createObjectLiteralExpression, factoryDeprecation);
+      updateObjectLiteral = deprecate(factory.updateObjectLiteralExpression, factoryDeprecation);
+      createPropertyAccess = deprecate(factory.createPropertyAccessExpression, factoryDeprecation);
+      updatePropertyAccess = deprecate(factory.updatePropertyAccessExpression, factoryDeprecation);
+      createPropertyAccessChain = deprecate(factory.createPropertyAccessChain, factoryDeprecation);
+      updatePropertyAccessChain = deprecate(factory.updatePropertyAccessChain, factoryDeprecation);
+      createElementAccess = deprecate(factory.createElementAccessExpression, factoryDeprecation);
+      updateElementAccess = deprecate(factory.updateElementAccessExpression, factoryDeprecation);
+      createElementAccessChain = deprecate(factory.createElementAccessChain, factoryDeprecation);
+      updateElementAccessChain = deprecate(factory.updateElementAccessChain, factoryDeprecation);
+      createCall = deprecate(factory.createCallExpression, factoryDeprecation);
+      updateCall = deprecate(factory.updateCallExpression, factoryDeprecation);
+      createCallChain = deprecate(factory.createCallChain, factoryDeprecation);
+      updateCallChain = deprecate(factory.updateCallChain, factoryDeprecation);
+      createNew = deprecate(factory.createNewExpression, factoryDeprecation);
+      updateNew = deprecate(factory.updateNewExpression, factoryDeprecation);
+      createTypeAssertion = deprecate(factory.createTypeAssertion, factoryDeprecation);
+      updateTypeAssertion = deprecate(factory.updateTypeAssertion, factoryDeprecation);
+      createParen = deprecate(factory.createParenthesizedExpression, factoryDeprecation);
+      updateParen = deprecate(factory.updateParenthesizedExpression, factoryDeprecation);
+      createFunctionExpression = deprecate(factory.createFunctionExpression, factoryDeprecation);
+      updateFunctionExpression = deprecate(factory.updateFunctionExpression, factoryDeprecation);
+      createDelete = deprecate(factory.createDeleteExpression, factoryDeprecation);
+      updateDelete = deprecate(factory.updateDeleteExpression, factoryDeprecation);
+      createTypeOf = deprecate(factory.createTypeOfExpression, factoryDeprecation);
+      updateTypeOf = deprecate(factory.updateTypeOfExpression, factoryDeprecation);
+      createVoid = deprecate(factory.createVoidExpression, factoryDeprecation);
+      updateVoid = deprecate(factory.updateVoidExpression, factoryDeprecation);
+      createAwait = deprecate(factory.createAwaitExpression, factoryDeprecation);
+      updateAwait = deprecate(factory.updateAwaitExpression, factoryDeprecation);
+      createPrefix = deprecate(factory.createPrefixUnaryExpression, factoryDeprecation);
+      updatePrefix = deprecate(factory.updatePrefixUnaryExpression, factoryDeprecation);
+      createPostfix = deprecate(factory.createPostfixUnaryExpression, factoryDeprecation);
+      updatePostfix = deprecate(factory.updatePostfixUnaryExpression, factoryDeprecation);
+      createBinary = deprecate(factory.createBinaryExpression, factoryDeprecation);
+      updateConditional = deprecate(factory.updateConditionalExpression, factoryDeprecation);
+      createTemplateExpression = deprecate(factory.createTemplateExpression, factoryDeprecation);
+      updateTemplateExpression = deprecate(factory.updateTemplateExpression, factoryDeprecation);
+      createTemplateHead = deprecate(factory.createTemplateHead, factoryDeprecation);
+      createTemplateMiddle = deprecate(factory.createTemplateMiddle, factoryDeprecation);
+      createTemplateTail = deprecate(factory.createTemplateTail, factoryDeprecation);
+      createNoSubstitutionTemplateLiteral = deprecate(factory.createNoSubstitutionTemplateLiteral, factoryDeprecation);
+      updateYield = deprecate(factory.updateYieldExpression, factoryDeprecation);
+      createSpread = deprecate(factory.createSpreadElement, factoryDeprecation);
+      updateSpread = deprecate(factory.updateSpreadElement, factoryDeprecation);
+      createOmittedExpression = deprecate(factory.createOmittedExpression, factoryDeprecation);
+      createAsExpression = deprecate(factory.createAsExpression, factoryDeprecation);
+      updateAsExpression = deprecate(factory.updateAsExpression, factoryDeprecation);
+      createNonNullExpression = deprecate(factory.createNonNullExpression, factoryDeprecation);
+      updateNonNullExpression = deprecate(factory.updateNonNullExpression, factoryDeprecation);
+      createNonNullChain = deprecate(factory.createNonNullChain, factoryDeprecation);
+      updateNonNullChain = deprecate(factory.updateNonNullChain, factoryDeprecation);
+      createMetaProperty = deprecate(factory.createMetaProperty, factoryDeprecation);
+      updateMetaProperty = deprecate(factory.updateMetaProperty, factoryDeprecation);
+      createTemplateSpan = deprecate(factory.createTemplateSpan, factoryDeprecation);
+      updateTemplateSpan = deprecate(factory.updateTemplateSpan, factoryDeprecation);
+      createSemicolonClassElement = deprecate(factory.createSemicolonClassElement, factoryDeprecation);
+      createBlock = deprecate(factory.createBlock, factoryDeprecation);
+      updateBlock = deprecate(factory.updateBlock, factoryDeprecation);
+      createVariableStatement = deprecate(factory.createVariableStatement, factoryDeprecation);
+      updateVariableStatement = deprecate(factory.updateVariableStatement, factoryDeprecation);
+      createEmptyStatement = deprecate(factory.createEmptyStatement, factoryDeprecation);
+      createExpressionStatement = deprecate(factory.createExpressionStatement, factoryDeprecation);
+      updateExpressionStatement = deprecate(factory.updateExpressionStatement, factoryDeprecation);
+      createStatement = deprecate(factory.createExpressionStatement, factoryDeprecation);
+      updateStatement = deprecate(factory.updateExpressionStatement, factoryDeprecation);
+      createIf = deprecate(factory.createIfStatement, factoryDeprecation);
+      updateIf = deprecate(factory.updateIfStatement, factoryDeprecation);
+      createDo = deprecate(factory.createDoStatement, factoryDeprecation);
+      updateDo = deprecate(factory.updateDoStatement, factoryDeprecation);
+      createWhile = deprecate(factory.createWhileStatement, factoryDeprecation);
+      updateWhile = deprecate(factory.updateWhileStatement, factoryDeprecation);
+      createFor = deprecate(factory.createForStatement, factoryDeprecation);
+      updateFor = deprecate(factory.updateForStatement, factoryDeprecation);
+      createForIn = deprecate(factory.createForInStatement, factoryDeprecation);
+      updateForIn = deprecate(factory.updateForInStatement, factoryDeprecation);
+      createForOf = deprecate(factory.createForOfStatement, factoryDeprecation);
+      updateForOf = deprecate(factory.updateForOfStatement, factoryDeprecation);
+      createContinue = deprecate(factory.createContinueStatement, factoryDeprecation);
+      updateContinue = deprecate(factory.updateContinueStatement, factoryDeprecation);
+      createBreak = deprecate(factory.createBreakStatement, factoryDeprecation);
+      updateBreak = deprecate(factory.updateBreakStatement, factoryDeprecation);
+      createReturn = deprecate(factory.createReturnStatement, factoryDeprecation);
+      updateReturn = deprecate(factory.updateReturnStatement, factoryDeprecation);
+      createWith = deprecate(factory.createWithStatement, factoryDeprecation);
+      updateWith = deprecate(factory.updateWithStatement, factoryDeprecation);
+      createSwitch = deprecate(factory.createSwitchStatement, factoryDeprecation);
+      updateSwitch = deprecate(factory.updateSwitchStatement, factoryDeprecation);
+      createLabel = deprecate(factory.createLabeledStatement, factoryDeprecation);
+      updateLabel = deprecate(factory.updateLabeledStatement, factoryDeprecation);
+      createThrow = deprecate(factory.createThrowStatement, factoryDeprecation);
+      updateThrow = deprecate(factory.updateThrowStatement, factoryDeprecation);
+      createTry = deprecate(factory.createTryStatement, factoryDeprecation);
+      updateTry = deprecate(factory.updateTryStatement, factoryDeprecation);
+      createDebuggerStatement = deprecate(factory.createDebuggerStatement, factoryDeprecation);
+      createVariableDeclarationList = deprecate(factory.createVariableDeclarationList, factoryDeprecation);
+      updateVariableDeclarationList = deprecate(factory.updateVariableDeclarationList, factoryDeprecation);
+      createFunctionDeclaration = deprecate(factory.createFunctionDeclaration, factoryDeprecation);
+      updateFunctionDeclaration = deprecate(factory.updateFunctionDeclaration, factoryDeprecation);
+      createClassDeclaration = deprecate(factory.createClassDeclaration, factoryDeprecation);
+      updateClassDeclaration = deprecate(factory.updateClassDeclaration, factoryDeprecation);
+      createInterfaceDeclaration = deprecate(factory.createInterfaceDeclaration, factoryDeprecation);
+      updateInterfaceDeclaration = deprecate(factory.updateInterfaceDeclaration, factoryDeprecation);
+      createTypeAliasDeclaration = deprecate(factory.createTypeAliasDeclaration, factoryDeprecation);
+      updateTypeAliasDeclaration = deprecate(factory.updateTypeAliasDeclaration, factoryDeprecation);
+      createEnumDeclaration = deprecate(factory.createEnumDeclaration, factoryDeprecation);
+      updateEnumDeclaration = deprecate(factory.updateEnumDeclaration, factoryDeprecation);
+      createModuleDeclaration = deprecate(factory.createModuleDeclaration, factoryDeprecation);
+      updateModuleDeclaration = deprecate(factory.updateModuleDeclaration, factoryDeprecation);
+      createModuleBlock = deprecate(factory.createModuleBlock, factoryDeprecation);
+      updateModuleBlock = deprecate(factory.updateModuleBlock, factoryDeprecation);
+      createCaseBlock = deprecate(factory.createCaseBlock, factoryDeprecation);
+      updateCaseBlock = deprecate(factory.updateCaseBlock, factoryDeprecation);
+      createNamespaceExportDeclaration = deprecate(factory.createNamespaceExportDeclaration, factoryDeprecation);
+      updateNamespaceExportDeclaration = deprecate(factory.updateNamespaceExportDeclaration, factoryDeprecation);
+      createImportEqualsDeclaration = deprecate(factory.createImportEqualsDeclaration, factoryDeprecation);
+      updateImportEqualsDeclaration = deprecate(factory.updateImportEqualsDeclaration, factoryDeprecation);
+      createImportDeclaration = deprecate(factory.createImportDeclaration, factoryDeprecation);
+      updateImportDeclaration = deprecate(factory.updateImportDeclaration, factoryDeprecation);
+      createNamespaceImport = deprecate(factory.createNamespaceImport, factoryDeprecation);
+      updateNamespaceImport = deprecate(factory.updateNamespaceImport, factoryDeprecation);
+      createNamedImports = deprecate(factory.createNamedImports, factoryDeprecation);
+      updateNamedImports = deprecate(factory.updateNamedImports, factoryDeprecation);
+      createImportSpecifier = deprecate(factory.createImportSpecifier, factoryDeprecation);
+      updateImportSpecifier = deprecate(factory.updateImportSpecifier, factoryDeprecation);
+      createExportAssignment2 = deprecate(factory.createExportAssignment, factoryDeprecation);
+      updateExportAssignment = deprecate(factory.updateExportAssignment, factoryDeprecation);
+      createNamedExports = deprecate(factory.createNamedExports, factoryDeprecation);
+      updateNamedExports = deprecate(factory.updateNamedExports, factoryDeprecation);
+      createExportSpecifier = deprecate(factory.createExportSpecifier, factoryDeprecation);
+      updateExportSpecifier = deprecate(factory.updateExportSpecifier, factoryDeprecation);
+      createExternalModuleReference = deprecate(factory.createExternalModuleReference, factoryDeprecation);
+      updateExternalModuleReference = deprecate(factory.updateExternalModuleReference, factoryDeprecation);
+      createJSDocTypeExpression = deprecate(factory.createJSDocTypeExpression, factoryDeprecation);
+      createJSDocTypeTag = deprecate(factory.createJSDocTypeTag, factoryDeprecation);
+      createJSDocReturnTag = deprecate(factory.createJSDocReturnTag, factoryDeprecation);
+      createJSDocThisTag = deprecate(factory.createJSDocThisTag, factoryDeprecation);
+      createJSDocComment = deprecate(factory.createJSDocComment, factoryDeprecation);
+      createJSDocParameterTag = deprecate(factory.createJSDocParameterTag, factoryDeprecation);
+      createJSDocClassTag = deprecate(factory.createJSDocClassTag, factoryDeprecation);
+      createJSDocAugmentsTag = deprecate(factory.createJSDocAugmentsTag, factoryDeprecation);
+      createJSDocEnumTag = deprecate(factory.createJSDocEnumTag, factoryDeprecation);
+      createJSDocTemplateTag = deprecate(factory.createJSDocTemplateTag, factoryDeprecation);
+      createJSDocTypedefTag = deprecate(factory.createJSDocTypedefTag, factoryDeprecation);
+      createJSDocCallbackTag = deprecate(factory.createJSDocCallbackTag, factoryDeprecation);
+      createJSDocSignature = deprecate(factory.createJSDocSignature, factoryDeprecation);
+      createJSDocPropertyTag = deprecate(factory.createJSDocPropertyTag, factoryDeprecation);
+      createJSDocTypeLiteral = deprecate(factory.createJSDocTypeLiteral, factoryDeprecation);
+      createJSDocImplementsTag = deprecate(factory.createJSDocImplementsTag, factoryDeprecation);
+      createJSDocAuthorTag = deprecate(factory.createJSDocAuthorTag, factoryDeprecation);
+      createJSDocPublicTag = deprecate(factory.createJSDocPublicTag, factoryDeprecation);
+      createJSDocPrivateTag = deprecate(factory.createJSDocPrivateTag, factoryDeprecation);
+      createJSDocProtectedTag = deprecate(factory.createJSDocProtectedTag, factoryDeprecation);
+      createJSDocReadonlyTag = deprecate(factory.createJSDocReadonlyTag, factoryDeprecation);
+      createJSDocTag = deprecate(factory.createJSDocUnknownTag, factoryDeprecation);
+      createJsxElement = deprecate(factory.createJsxElement, factoryDeprecation);
+      updateJsxElement = deprecate(factory.updateJsxElement, factoryDeprecation);
+      createJsxSelfClosingElement = deprecate(factory.createJsxSelfClosingElement, factoryDeprecation);
+      updateJsxSelfClosingElement = deprecate(factory.updateJsxSelfClosingElement, factoryDeprecation);
+      createJsxOpeningElement = deprecate(factory.createJsxOpeningElement, factoryDeprecation);
+      updateJsxOpeningElement = deprecate(factory.updateJsxOpeningElement, factoryDeprecation);
+      createJsxClosingElement = deprecate(factory.createJsxClosingElement, factoryDeprecation);
+      updateJsxClosingElement = deprecate(factory.updateJsxClosingElement, factoryDeprecation);
+      createJsxFragment = deprecate(factory.createJsxFragment, factoryDeprecation);
+      createJsxText = deprecate(factory.createJsxText, factoryDeprecation);
+      updateJsxText = deprecate(factory.updateJsxText, factoryDeprecation);
+      createJsxOpeningFragment = deprecate(factory.createJsxOpeningFragment, factoryDeprecation);
+      createJsxJsxClosingFragment = deprecate(factory.createJsxJsxClosingFragment, factoryDeprecation);
+      updateJsxFragment = deprecate(factory.updateJsxFragment, factoryDeprecation);
+      createJsxAttribute = deprecate(factory.createJsxAttribute, factoryDeprecation);
+      updateJsxAttribute = deprecate(factory.updateJsxAttribute, factoryDeprecation);
+      createJsxAttributes = deprecate(factory.createJsxAttributes, factoryDeprecation);
+      updateJsxAttributes = deprecate(factory.updateJsxAttributes, factoryDeprecation);
+      createJsxSpreadAttribute = deprecate(factory.createJsxSpreadAttribute, factoryDeprecation);
+      updateJsxSpreadAttribute = deprecate(factory.updateJsxSpreadAttribute, factoryDeprecation);
+      createJsxExpression = deprecate(factory.createJsxExpression, factoryDeprecation);
+      updateJsxExpression = deprecate(factory.updateJsxExpression, factoryDeprecation);
+      createCaseClause = deprecate(factory.createCaseClause, factoryDeprecation);
+      updateCaseClause = deprecate(factory.updateCaseClause, factoryDeprecation);
+      createDefaultClause = deprecate(factory.createDefaultClause, factoryDeprecation);
+      updateDefaultClause = deprecate(factory.updateDefaultClause, factoryDeprecation);
+      createHeritageClause = deprecate(factory.createHeritageClause, factoryDeprecation);
+      updateHeritageClause = deprecate(factory.updateHeritageClause, factoryDeprecation);
+      createCatchClause = deprecate(factory.createCatchClause, factoryDeprecation);
+      updateCatchClause = deprecate(factory.updateCatchClause, factoryDeprecation);
+      createPropertyAssignment = deprecate(factory.createPropertyAssignment, factoryDeprecation);
+      updatePropertyAssignment = deprecate(factory.updatePropertyAssignment, factoryDeprecation);
+      createShorthandPropertyAssignment = deprecate(factory.createShorthandPropertyAssignment, factoryDeprecation);
+      updateShorthandPropertyAssignment = deprecate(factory.updateShorthandPropertyAssignment, factoryDeprecation);
+      createSpreadAssignment = deprecate(factory.createSpreadAssignment, factoryDeprecation);
+      updateSpreadAssignment = deprecate(factory.updateSpreadAssignment, factoryDeprecation);
+      createEnumMember = deprecate(factory.createEnumMember, factoryDeprecation);
+      updateEnumMember = deprecate(factory.updateEnumMember, factoryDeprecation);
+      updateSourceFileNode = deprecate(factory.updateSourceFile, factoryDeprecation);
+      createNotEmittedStatement = deprecate(factory.createNotEmittedStatement, factoryDeprecation);
+      createPartiallyEmittedExpression = deprecate(factory.createPartiallyEmittedExpression, factoryDeprecation);
+      updatePartiallyEmittedExpression = deprecate(factory.updatePartiallyEmittedExpression, factoryDeprecation);
+      createCommaList = deprecate(factory.createCommaListExpression, factoryDeprecation);
+      updateCommaList = deprecate(factory.updateCommaListExpression, factoryDeprecation);
+      createBundle = deprecate(factory.createBundle, factoryDeprecation);
+      updateBundle = deprecate(factory.updateBundle, factoryDeprecation);
+      createImmediatelyInvokedFunctionExpression = deprecate(factory.createImmediatelyInvokedFunctionExpression, factoryDeprecation);
+      createImmediatelyInvokedArrowFunction = deprecate(factory.createImmediatelyInvokedArrowFunction, factoryDeprecation);
+      createVoidZero = deprecate(factory.createVoidZero, factoryDeprecation);
+      createExportDefault = deprecate(factory.createExportDefault, factoryDeprecation);
+      createExternalModuleExport = deprecate(factory.createExternalModuleExport, factoryDeprecation);
+      createNamespaceExport = deprecate(factory.createNamespaceExport, factoryDeprecation);
+      updateNamespaceExport = deprecate(factory.updateNamespaceExport, factoryDeprecation);
+      createToken = deprecate(function createToken2(kind) {
         return factory.createToken(kind);
       }, factoryDeprecation);
-      createIdentifier = Debug.deprecate(function createIdentifier2(text) {
+      createIdentifier = deprecate(function createIdentifier2(text) {
         return factory.createIdentifier(text, void 0, void 0);
       }, factoryDeprecation);
-      createTempVariable = Debug.deprecate(function createTempVariable2(recordTempVariable) {
+      createTempVariable = deprecate(function createTempVariable2(recordTempVariable) {
         return factory.createTempVariable(recordTempVariable, void 0);
       }, factoryDeprecation);
-      getGeneratedNameForNode = Debug.deprecate(function getGeneratedNameForNode2(node) {
+      getGeneratedNameForNode = deprecate(function getGeneratedNameForNode2(node) {
         return factory.getGeneratedNameForNode(node, void 0);
       }, factoryDeprecation);
-      createOptimisticUniqueName = Debug.deprecate(function createOptimisticUniqueName2(text) {
+      createOptimisticUniqueName = deprecate(function createOptimisticUniqueName2(text) {
         return factory.createUniqueName(text, 16 /* Optimistic */);
       }, factoryDeprecation);
-      createFileLevelUniqueName = Debug.deprecate(function createFileLevelUniqueName2(text) {
+      createFileLevelUniqueName = deprecate(function createFileLevelUniqueName2(text) {
         return factory.createUniqueName(text, 16 /* Optimistic */ | 32 /* FileLevel */);
       }, factoryDeprecation);
-      createIndexSignature = Debug.deprecate(function createIndexSignature2(decorators, modifiers, parameters, type) {
+      createIndexSignature = deprecate(function createIndexSignature2(decorators, modifiers, parameters, type) {
         return factory.createIndexSignature(decorators, modifiers, parameters, type);
       }, factoryDeprecation);
-      createTypePredicateNode = Debug.deprecate(function createTypePredicateNode2(parameterName, type) {
+      createTypePredicateNode = deprecate(function createTypePredicateNode2(parameterName, type) {
         return factory.createTypePredicateNode(void 0, parameterName, type);
       }, factoryDeprecation);
-      updateTypePredicateNode = Debug.deprecate(function updateTypePredicateNode2(node, parameterName, type) {
+      updateTypePredicateNode = deprecate(function updateTypePredicateNode2(node, parameterName, type) {
         return factory.updateTypePredicateNode(node, void 0, parameterName, type);
       }, factoryDeprecation);
-      createLiteral = Debug.deprecate(function createLiteral2(value) {
+      createLiteral = deprecate(function createLiteral2(value) {
         if (typeof value === "number") {
           return factory.createNumericLiteral(value);
         }
@@ -147318,13 +147314,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." });
-      createMethodSignature = Debug.deprecate(function createMethodSignature2(typeParameters, parameters, type, name, questionToken) {
+      createMethodSignature = deprecate(function createMethodSignature2(typeParameters, parameters, type, name, questionToken) {
         return factory.createMethodSignature(void 0, name, questionToken, typeParameters, parameters, type);
       }, factoryDeprecation);
-      updateMethodSignature = Debug.deprecate(function updateMethodSignature2(node, typeParameters, parameters, type, name, questionToken) {
+      updateMethodSignature = deprecate(function updateMethodSignature2(node, typeParameters, parameters, type, name, questionToken) {
         return factory.updateMethodSignature(node, node.modifiers, name, questionToken, typeParameters, parameters, type);
       }, factoryDeprecation);
-      createTypeOperatorNode = Debug.deprecate(function createTypeOperatorNode2(operatorOrType, type) {
+      createTypeOperatorNode = deprecate(function createTypeOperatorNode2(operatorOrType, type) {
         let operator;
         if (type) {
           operator = operatorOrType;
@@ -147334,7 +147330,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         return factory.createTypeOperatorNode(operator, type);
       }, factoryDeprecation);
-      createTaggedTemplate = Debug.deprecate(function createTaggedTemplate2(tag, typeArgumentsOrTemplate, template) {
+      createTaggedTemplate = deprecate(function createTaggedTemplate2(tag, typeArgumentsOrTemplate, template) {
         let typeArguments;
         if (template) {
           typeArguments = typeArgumentsOrTemplate;
@@ -147343,7 +147339,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         return factory.createTaggedTemplateExpression(tag, typeArguments, template);
       }, factoryDeprecation);
-      updateTaggedTemplate = Debug.deprecate(function updateTaggedTemplate2(node, tag, typeArgumentsOrTemplate, template) {
+      updateTaggedTemplate = deprecate(function updateTaggedTemplate2(node, tag, typeArgumentsOrTemplate, template) {
         let typeArguments;
         if (template) {
           typeArguments = typeArgumentsOrTemplate;
@@ -147352,16 +147348,16 @@ ${options.prefix}` : "\n" : options.prefix
         }
         return factory.updateTaggedTemplateExpression(node, tag, typeArguments, template);
       }, factoryDeprecation);
-      updateBinary = Debug.deprecate(function updateBinary2(node, left, right, operator = node.operatorToken) {
+      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);
-      createConditional = Debug.deprecate(function createConditional2(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) {
+      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);
-      createYield = Debug.deprecate(function createYield2(asteriskTokenOrExpression, expression) {
+      createYield = deprecate(function createYield2(asteriskTokenOrExpression, expression) {
         let asteriskToken;
         if (expression) {
           asteriskToken = asteriskTokenOrExpression;
@@ -147370,18 +147366,18 @@ ${options.prefix}` : "\n" : options.prefix
         }
         return factory.createYieldExpression(asteriskToken, expression);
       }, factoryDeprecation);
-      createClassExpression = Debug.deprecate(function createClassExpression2(modifiers, name, typeParameters, heritageClauses, members) {
+      createClassExpression = deprecate(function createClassExpression2(modifiers, name, typeParameters, heritageClauses, members) {
         return factory.createClassExpression(void 0, modifiers, name, typeParameters, heritageClauses, members);
       }, factoryDeprecation);
-      updateClassExpression = Debug.deprecate(function updateClassExpression2(node, modifiers, name, typeParameters, heritageClauses, members) {
+      updateClassExpression = deprecate(function updateClassExpression2(node, modifiers, name, typeParameters, heritageClauses, members) {
         return factory.updateClassExpression(node, void 0, modifiers, name, typeParameters, heritageClauses, members);
       }, factoryDeprecation);
-      createPropertySignature = Debug.deprecate(function createPropertySignature2(modifiers, name, questionToken, type, initializer) {
+      createPropertySignature = deprecate(function createPropertySignature2(modifiers, name, questionToken, type, initializer) {
         const node = factory.createPropertySignature(modifiers, name, questionToken, type);
         node.initializer = initializer;
         return node;
       }, factoryDeprecation);
-      updatePropertySignature = Debug.deprecate(function updatePropertySignature2(node, modifiers, name, questionToken, type, initializer) {
+      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) {
@@ -147391,80 +147387,80 @@ ${options.prefix}` : "\n" : options.prefix
         }
         return updated;
       }, factoryDeprecation);
-      createExpressionWithTypeArguments = Debug.deprecate(function createExpressionWithTypeArguments2(typeArguments, expression) {
+      createExpressionWithTypeArguments = deprecate(function createExpressionWithTypeArguments2(typeArguments, expression) {
         return factory.createExpressionWithTypeArguments(expression, typeArguments);
       }, factoryDeprecation);
-      updateExpressionWithTypeArguments = Debug.deprecate(function updateExpressionWithTypeArguments2(node, typeArguments, expression) {
+      updateExpressionWithTypeArguments = deprecate(function updateExpressionWithTypeArguments2(node, typeArguments, expression) {
         return factory.updateExpressionWithTypeArguments(node, expression, typeArguments);
       }, factoryDeprecation);
-      createArrowFunction = Debug.deprecate(function createArrowFunction2(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
+      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);
-      updateArrowFunction = Debug.deprecate(function updateArrowFunction2(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
+      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);
-      createVariableDeclaration = Debug.deprecate(function createVariableDeclaration2(name, exclamationTokenOrType, typeOrInitializer, initializer) {
+      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);
-      updateVariableDeclaration = Debug.deprecate(function updateVariableDeclaration2(node, name, exclamationTokenOrType, typeOrInitializer, initializer) {
+      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);
-      createImportClause = Debug.deprecate(function createImportClause2(name, namedBindings, isTypeOnly = false) {
+      createImportClause = deprecate(function createImportClause2(name, namedBindings, isTypeOnly = false) {
         return factory.createImportClause(isTypeOnly, name, namedBindings);
       }, factoryDeprecation);
-      updateImportClause = Debug.deprecate(function updateImportClause2(node, name, namedBindings, isTypeOnly) {
+      updateImportClause = deprecate(function updateImportClause2(node, name, namedBindings, isTypeOnly) {
         return factory.updateImportClause(node, isTypeOnly, name, namedBindings);
       }, factoryDeprecation);
-      createExportDeclaration = Debug.deprecate(function createExportDeclaration2(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly = false) {
+      createExportDeclaration = deprecate(function createExportDeclaration2(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly = false) {
         return factory.createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier);
       }, factoryDeprecation);
-      updateExportDeclaration = Debug.deprecate(function updateExportDeclaration2(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
+      updateExportDeclaration = deprecate(function updateExportDeclaration2(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
         return factory.updateExportDeclaration(node, decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, node.assertClause);
       }, factoryDeprecation);
-      createJSDocParamTag = Debug.deprecate(function createJSDocParamTag2(name, isBracketed, typeExpression, comment) {
+      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);
-      createComma = Debug.deprecate(function createComma2(left, right) {
+      createComma = deprecate(function createComma2(left, right) {
         return factory.createComma(left, right);
       }, factoryDeprecation);
-      createLessThan = Debug.deprecate(function createLessThan2(left, right) {
+      createLessThan = deprecate(function createLessThan2(left, right) {
         return factory.createLessThan(left, right);
       }, factoryDeprecation);
-      createAssignment = Debug.deprecate(function createAssignment2(left, right) {
+      createAssignment = deprecate(function createAssignment2(left, right) {
         return factory.createAssignment(left, right);
       }, factoryDeprecation);
-      createStrictEquality = Debug.deprecate(function createStrictEquality2(left, right) {
+      createStrictEquality = deprecate(function createStrictEquality2(left, right) {
         return factory.createStrictEquality(left, right);
       }, factoryDeprecation);
-      createStrictInequality = Debug.deprecate(function createStrictInequality2(left, right) {
+      createStrictInequality = deprecate(function createStrictInequality2(left, right) {
         return factory.createStrictInequality(left, right);
       }, factoryDeprecation);
-      createAdd = Debug.deprecate(function createAdd2(left, right) {
+      createAdd = deprecate(function createAdd2(left, right) {
         return factory.createAdd(left, right);
       }, factoryDeprecation);
-      createSubtract = Debug.deprecate(function createSubtract2(left, right) {
+      createSubtract = deprecate(function createSubtract2(left, right) {
         return factory.createSubtract(left, right);
       }, factoryDeprecation);
-      createLogicalAnd = Debug.deprecate(function createLogicalAnd2(left, right) {
+      createLogicalAnd = deprecate(function createLogicalAnd2(left, right) {
         return factory.createLogicalAnd(left, right);
       }, factoryDeprecation);
-      createLogicalOr = Debug.deprecate(function createLogicalOr2(left, right) {
+      createLogicalOr = deprecate(function createLogicalOr2(left, right) {
         return factory.createLogicalOr(left, right);
       }, factoryDeprecation);
-      createPostfixIncrement = Debug.deprecate(function createPostfixIncrement2(operand) {
+      createPostfixIncrement = deprecate(function createPostfixIncrement2(operand) {
         return factory.createPostfixIncrement(operand);
       }, factoryDeprecation);
-      createLogicalNot = Debug.deprecate(function createLogicalNot2(operand) {
+      createLogicalNot = deprecate(function createLogicalNot2(operand) {
         return factory.createLogicalNot(operand);
       }, factoryDeprecation);
-      createNode2 = Debug.deprecate(function createNode3(kind, pos = 0, end = 0) {
+      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." });
-      getMutableClone = Debug.deprecate(function getMutableClone2(node) {
+      getMutableClone = deprecate(function getMutableClone2(node) {
         const clone2 = factory.cloneNode(node);
         setTextRange(clone2, node);
         setParent(clone2, node.parent);
@@ -147479,7 +147475,8 @@ ${options.prefix}` : "\n" : options.prefix
     "src/deprecatedCompat/4.0/renamedNodeTests.ts"() {
       "use strict";
       init_ts5();
-      isTypeAssertion = Debug.deprecate(function isTypeAssertion2(node) {
+      init_deprecate();
+      isTypeAssertion = deprecate(function isTypeAssertion2(node) {
         return node.kind === 213 /* TypeAssertionExpression */;
       }, {
         since: "4.0",
@@ -147495,7 +147492,8 @@ ${options.prefix}` : "\n" : options.prefix
     "src/deprecatedCompat/4.2/renamedNodeTests.ts"() {
       "use strict";
       init_ts5();
-      isIdentifierOrPrivateIdentifier = Debug.deprecate(function isIdentifierOrPrivateIdentifier2(node) {
+      init_deprecate();
+      isIdentifierOrPrivateIdentifier = deprecate(function isIdentifierOrPrivateIdentifier2(node) {
         return isMemberName(node);
       }, {
         since: "4.2",
@@ -150413,6 +150411,7 @@ ${options.prefix}` : "\n" : options.prefix
     supportedLocaleDirectories: () => supportedLocaleDirectories,
     supportedTSExtensions: () => supportedTSExtensions,
     supportedTSExtensionsFlat: () => supportedTSExtensionsFlat,
+    supportedTSImplementationExtensions: () => supportedTSImplementationExtensions,
     suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia,
     suppressLeadingTrivia: () => suppressLeadingTrivia,
     suppressTrailingTrivia: () => suppressTrailingTrivia,