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

package/lib/typescript.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-insiders.20221111`;
+      version = `${versionMajorMinor}.0-insiders.20221123`;
       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]" : "";
@@ -4372,6 +4320,7 @@ ${lanes.join("\n")}
         return EnumKind2;
       })(EnumKind || {});
       CheckFlags = /* @__PURE__ */ ((CheckFlags2) => {
+        CheckFlags2[CheckFlags2["None"] = 0] = "None";
         CheckFlags2[CheckFlags2["Instantiated"] = 1] = "Instantiated";
         CheckFlags2[CheckFlags2["SyntheticProperty"] = 2] = "SyntheticProperty";
         CheckFlags2[CheckFlags2["SyntheticMethod"] = 4] = "SyntheticMethod";
@@ -4419,31 +4368,32 @@ ${lanes.join("\n")}
         return InternalSymbolName2;
       })(InternalSymbolName || {});
       NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags2) => {
+        NodeCheckFlags2[NodeCheckFlags2["None"] = 0] = "None";
         NodeCheckFlags2[NodeCheckFlags2["TypeChecked"] = 1] = "TypeChecked";
         NodeCheckFlags2[NodeCheckFlags2["LexicalThis"] = 2] = "LexicalThis";
         NodeCheckFlags2[NodeCheckFlags2["CaptureThis"] = 4] = "CaptureThis";
         NodeCheckFlags2[NodeCheckFlags2["CaptureNewTarget"] = 8] = "CaptureNewTarget";
-        NodeCheckFlags2[NodeCheckFlags2["SuperInstance"] = 256] = "SuperInstance";
-        NodeCheckFlags2[NodeCheckFlags2["SuperStatic"] = 512] = "SuperStatic";
-        NodeCheckFlags2[NodeCheckFlags2["ContextChecked"] = 1024] = "ContextChecked";
-        NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAccessInAsync"] = 2048] = "MethodWithSuperPropertyAccessInAsync";
-        NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAssignmentInAsync"] = 4096] = "MethodWithSuperPropertyAssignmentInAsync";
-        NodeCheckFlags2[NodeCheckFlags2["CaptureArguments"] = 8192] = "CaptureArguments";
-        NodeCheckFlags2[NodeCheckFlags2["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
-        NodeCheckFlags2[NodeCheckFlags2["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
-        NodeCheckFlags2[NodeCheckFlags2["LoopWithCapturedBlockScopedBinding"] = 65536] = "LoopWithCapturedBlockScopedBinding";
-        NodeCheckFlags2[NodeCheckFlags2["ContainsCapturedBlockScopeBinding"] = 131072] = "ContainsCapturedBlockScopeBinding";
-        NodeCheckFlags2[NodeCheckFlags2["CapturedBlockScopedBinding"] = 262144] = "CapturedBlockScopedBinding";
-        NodeCheckFlags2[NodeCheckFlags2["BlockScopedBindingInLoop"] = 524288] = "BlockScopedBindingInLoop";
-        NodeCheckFlags2[NodeCheckFlags2["ClassWithBodyScopedClassBinding"] = 1048576] = "ClassWithBodyScopedClassBinding";
-        NodeCheckFlags2[NodeCheckFlags2["BodyScopedClassBinding"] = 2097152] = "BodyScopedClassBinding";
-        NodeCheckFlags2[NodeCheckFlags2["NeedsLoopOutParameter"] = 4194304] = "NeedsLoopOutParameter";
-        NodeCheckFlags2[NodeCheckFlags2["AssignmentsMarked"] = 8388608] = "AssignmentsMarked";
-        NodeCheckFlags2[NodeCheckFlags2["ClassWithConstructorReference"] = 16777216] = "ClassWithConstructorReference";
-        NodeCheckFlags2[NodeCheckFlags2["ConstructorReferenceInClass"] = 33554432] = "ConstructorReferenceInClass";
-        NodeCheckFlags2[NodeCheckFlags2["ContainsClassWithPrivateIdentifiers"] = 67108864] = "ContainsClassWithPrivateIdentifiers";
-        NodeCheckFlags2[NodeCheckFlags2["ContainsSuperPropertyInStaticInitializer"] = 134217728] = "ContainsSuperPropertyInStaticInitializer";
-        NodeCheckFlags2[NodeCheckFlags2["InCheckIdentifier"] = 268435456] = "InCheckIdentifier";
+        NodeCheckFlags2[NodeCheckFlags2["SuperInstance"] = 16] = "SuperInstance";
+        NodeCheckFlags2[NodeCheckFlags2["SuperStatic"] = 32] = "SuperStatic";
+        NodeCheckFlags2[NodeCheckFlags2["ContextChecked"] = 64] = "ContextChecked";
+        NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAccessInAsync"] = 128] = "MethodWithSuperPropertyAccessInAsync";
+        NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAssignmentInAsync"] = 256] = "MethodWithSuperPropertyAssignmentInAsync";
+        NodeCheckFlags2[NodeCheckFlags2["CaptureArguments"] = 512] = "CaptureArguments";
+        NodeCheckFlags2[NodeCheckFlags2["EnumValuesComputed"] = 1024] = "EnumValuesComputed";
+        NodeCheckFlags2[NodeCheckFlags2["LexicalModuleMergesWithClass"] = 2048] = "LexicalModuleMergesWithClass";
+        NodeCheckFlags2[NodeCheckFlags2["LoopWithCapturedBlockScopedBinding"] = 4096] = "LoopWithCapturedBlockScopedBinding";
+        NodeCheckFlags2[NodeCheckFlags2["ContainsCapturedBlockScopeBinding"] = 8192] = "ContainsCapturedBlockScopeBinding";
+        NodeCheckFlags2[NodeCheckFlags2["CapturedBlockScopedBinding"] = 16384] = "CapturedBlockScopedBinding";
+        NodeCheckFlags2[NodeCheckFlags2["BlockScopedBindingInLoop"] = 32768] = "BlockScopedBindingInLoop";
+        NodeCheckFlags2[NodeCheckFlags2["ClassWithBodyScopedClassBinding"] = 65536] = "ClassWithBodyScopedClassBinding";
+        NodeCheckFlags2[NodeCheckFlags2["BodyScopedClassBinding"] = 131072] = "BodyScopedClassBinding";
+        NodeCheckFlags2[NodeCheckFlags2["NeedsLoopOutParameter"] = 262144] = "NeedsLoopOutParameter";
+        NodeCheckFlags2[NodeCheckFlags2["AssignmentsMarked"] = 524288] = "AssignmentsMarked";
+        NodeCheckFlags2[NodeCheckFlags2["ClassWithConstructorReference"] = 1048576] = "ClassWithConstructorReference";
+        NodeCheckFlags2[NodeCheckFlags2["ConstructorReferenceInClass"] = 2097152] = "ConstructorReferenceInClass";
+        NodeCheckFlags2[NodeCheckFlags2["ContainsClassWithPrivateIdentifiers"] = 4194304] = "ContainsClassWithPrivateIdentifiers";
+        NodeCheckFlags2[NodeCheckFlags2["ContainsSuperPropertyInStaticInitializer"] = 8388608] = "ContainsSuperPropertyInStaticInitializer";
+        NodeCheckFlags2[NodeCheckFlags2["InCheckIdentifier"] = 16777216] = "InCheckIdentifier";
         return NodeCheckFlags2;
       })(NodeCheckFlags || {});
       TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
@@ -4516,6 +4466,7 @@ ${lanes.join("\n")}
         return TypeFlags2;
       })(TypeFlags || {});
       ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
+        ObjectFlags3[ObjectFlags3["None"] = 0] = "None";
         ObjectFlags3[ObjectFlags3["Class"] = 1] = "Class";
         ObjectFlags3[ObjectFlags3["Interface"] = 2] = "Interface";
         ObjectFlags3[ObjectFlags3["Reference"] = 4] = "Reference";
@@ -4633,6 +4584,7 @@ ${lanes.join("\n")}
         return TypeMapKind2;
       })(TypeMapKind || {});
       InferencePriority = /* @__PURE__ */ ((InferencePriority2) => {
+        InferencePriority2[InferencePriority2["None"] = 0] = "None";
         InferencePriority2[InferencePriority2["NakedTypeVariable"] = 1] = "NakedTypeVariable";
         InferencePriority2[InferencePriority2["SpeculativeTuple"] = 2] = "SpeculativeTuple";
         InferencePriority2[InferencePriority2["SubstituteSource"] = 4] = "SubstituteSource";
@@ -8112,10 +8064,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}'."),
@@ -17142,6 +17094,32 @@ ${lanes.join("\n")}
   function pseudoBigIntToString({ negative, base10Value }) {
     return (negative && base10Value !== "0" ? "-" : "") + base10Value;
   }
+  function parseBigInt(text) {
+    if (!isValidBigIntString(text, false)) {
+      return void 0;
+    }
+    return parseValidBigInt(text);
+  }
+  function parseValidBigInt(text) {
+    const negative = text.startsWith("-");
+    const base10Value = parsePseudoBigInt(`${negative ? text.slice(1) : text}n`);
+    return { negative, base10Value };
+  }
+  function isValidBigIntString(s, roundTripOnly) {
+    if (s === "")
+      return false;
+    const scanner2 = createScanner(99 /* ESNext */, false);
+    let success = true;
+    scanner2.setOnError(() => success = false);
+    scanner2.setText(s + "n");
+    let result = scanner2.scan();
+    const negative = result === 40 /* MinusToken */;
+    if (negative) {
+      result = scanner2.scan();
+    }
+    const flags = scanner2.getTokenFlags();
+    return success && result === 9 /* BigIntLiteral */ && scanner2.getTextPos() === s.length + 1 && !(flags & 512 /* ContainsSeparator */) && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner2.getTokenValue()) }));
+  }
   function isValidTypeOnlyAliasUseSite(useSite) {
     return !!(useSite.flags & 16777216 /* Ambient */) || isPartOfTypeQuery(useSite) || isIdentifierInNonEmittingHeritageClause(useSite) || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
   }
@@ -17468,7 +17446,11 @@ ${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;
+  function canUsePropertyAccess(name, languageVersion) {
+    const firstChar = name.charCodeAt(0);
+    return firstChar === 35 /* hash */ ? name.length > 1 && isIdentifierStart(name.charCodeAt(1), languageVersion) : isIdentifierStart(firstChar, languageVersion);
+  }
+  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 +17600,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 +23176,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 +34952,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 +35165,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 +35216,7 @@ ${lanes.join("\n")}
           }
           return resolvedTypeScriptOnly(
             loadNodeModuleFromDirectory(
-              4 /* DtsOnly */,
+              4 /* Declaration */,
               candidate,
               !directoryExists,
               moduleResolutionState
@@ -35241,11 +35237,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 +35758,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 +35810,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 +35848,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 +35889,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 +35946,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 +35956,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 +35968,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 +35981,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;
         }
-      case 3 /* TSConfig */:
-      case 2 /* Json */:
-        return tryExtension(".json" /* Json */);
+        if (extensions & 8 /* Json */) {
+          candidate = originalCandidate;
+          const result = tryExtension(".json" /* Json */);
+          if (result)
+            return result;
+        }
+        return void 0;
+      default:
+        return extensions & 1 /* TypeScript */ && (tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */)) || extensions & 4 /* Declaration */ && tryExtension(".d.ts" /* Dts */) || extensions & 2 /* JavaScript */ && (tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */)) || state.isConfigLookup && tryExtension(".json" /* Json */) || void 0;
     }
     function tryExtension(ext) {
       const path = tryFile(candidate + ext, onlyRecordFailures, state);
@@ -36066,7 +36049,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 +36137,8 @@ ${lanes.join("\n")}
       features: 0 /* None */,
       conditions: emptyArray,
       requestContainingDirectory: void 0,
-      reportDiagnostic: noop
+      reportDiagnostic: noop,
+      isConfigLookup: false
     };
   }
   function getPackageScopeForPath(fileName, state) {
@@ -36213,23 +36197,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 +36214,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 +36248,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 +36410,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 +36501,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 +36538,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 +36581,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 +36613,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 +36628,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 +36768,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 +36798,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 +36825,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 +36846,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 +36864,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 +39849,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);
@@ -39896,34 +39858,53 @@ ${lanes.join("\n")}
         return nodeModulesSpecifiers;
       }
       if (!specifier) {
-        const local = getLocalModuleSpecifier(modulePath.path, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
-        if (pathIsBareSpecifier(local)) {
+        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 (!modulePath.isRedirect && (!importedFileIsInNodeModules || modulePath.isInNodeModules)) {
+        } 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);
+    if (pathsOnly) {
+      return fromPaths;
+    }
     const maybeNonRelative = fromPaths === void 0 && baseUrl !== void 0 ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths;
     if (!maybeNonRelative) {
       return relativePath;
@@ -40429,7 +40410,7 @@ ${lanes.join("\n")}
   function SymbolLinks() {
   }
   function NodeLinks() {
-    this.flags = 0;
+    this.flags = 0 /* None */;
   }
   function getNodeId(node) {
     if (!node.id) {
@@ -41274,7 +41255,7 @@ ${lanes.join("\n")}
     function createSymbol(flags, name, checkFlags) {
       symbolCount++;
       const symbol = new Symbol46(flags | 33554432 /* Transient */, name);
-      symbol.checkFlags = checkFlags || 0;
+      symbol.checkFlags = checkFlags || 0 /* None */;
       return symbol;
     }
     function getExcludedSymbolFlags(flags) {
@@ -43585,7 +43566,7 @@ ${lanes.join("\n")}
     function createOriginType(flags) {
       return new Type27(checker, flags);
     }
-    function createIntrinsicType(kind, intrinsicName, objectFlags = 0) {
+    function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */) {
       const type = createType(kind);
       type.intrinsicName = intrinsicName;
       type.objectFlags = objectFlags;
@@ -44080,25 +44061,22 @@ ${lanes.join("\n")}
         const context = {
           enclosingDeclaration,
           flags: flags || 0 /* None */,
-          tracker: tracker && tracker.trackSymbol ? tracker : {
-            trackSymbol: () => false,
-            moduleResolverHost: flags & 134217728 /* DoNotIncludeSymbolChain */ ? {
-              getCommonSourceDirectory: !!host.getCommonSourceDirectory ? () => host.getCommonSourceDirectory() : () => "",
-              getCurrentDirectory: () => host.getCurrentDirectory(),
-              getSymlinkCache: maybeBind(host, host.getSymlinkCache),
-              getPackageJsonInfoCache: () => {
-                var _a3;
-                return (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host);
-              },
-              useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
-              redirectTargetsMap: host.redirectTargetsMap,
-              getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
-              isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
-              fileExists: (fileName) => host.fileExists(fileName),
-              getFileIncludeReasons: () => host.getFileIncludeReasons(),
-              readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
-            } : void 0
-          },
+          tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: () => false, moduleResolverHost: flags & 134217728 /* DoNotIncludeSymbolChain */ ? {
+            getCommonSourceDirectory: !!host.getCommonSourceDirectory ? () => host.getCommonSourceDirectory() : () => "",
+            getCurrentDirectory: () => host.getCurrentDirectory(),
+            getSymlinkCache: maybeBind(host, host.getSymlinkCache),
+            getPackageJsonInfoCache: () => {
+              var _a3;
+              return (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host);
+            },
+            useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
+            redirectTargetsMap: host.redirectTargetsMap,
+            getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
+            isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
+            fileExists: (fileName) => host.fileExists(fileName),
+            getFileIncludeReasons: () => host.getFileIncludeReasons(),
+            readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
+          } : void 0 },
           encounteredError: false,
           reportedDiagnostic: false,
           visitedTypes: void 0,
@@ -45455,8 +45433,7 @@ ${lanes.join("\n")}
           if (isSingleOrDoubleQuote(firstChar) && some(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
             return factory.createStringLiteral(getSpecifierForModuleSymbol(symbol2, context));
           }
-          const canUsePropertyAccess = firstChar === 35 /* hash */ ? symbolName2.length > 1 && isIdentifierStart(symbolName2.charCodeAt(1), languageVersion) : isIdentifierStart(firstChar, languageVersion);
-          if (index === 0 || canUsePropertyAccess) {
+          if (index === 0 || canUsePropertyAccess(symbolName2, languageVersion)) {
             const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 16777216 /* NoAsciiEscaping */);
             identifier.symbol = symbol2;
             return index > 0 ? factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), identifier) : identifier;
@@ -50429,7 +50406,7 @@ ${lanes.join("\n")}
     function containsArgumentsReference(declaration) {
       const links = getNodeLinks(declaration);
       if (links.containsArgumentsReference === void 0) {
-        if (links.flags & 8192 /* CaptureArguments */) {
+        if (links.flags & 512 /* CaptureArguments */) {
           links.containsArgumentsReference = true;
         } else {
           links.containsArgumentsReference = traverse(declaration.body);
@@ -54329,7 +54306,7 @@ ${lanes.join("\n")}
       return compareSignaturesRelated(
         source,
         target,
-        ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0,
+        ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0 /* None */,
         false,
         void 0,
         void 0,
@@ -54563,7 +54540,9 @@ ${lanes.join("\n")}
       if (relation === assignableRelation || relation === comparableRelation) {
         if (s & 1 /* Any */)
           return true;
-        if (s & (8 /* Number */ | 256 /* NumberLiteral */) && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || relation === assignableRelation && t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
+        if (s & 8 /* Number */ && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
+          return true;
+        if (s & 256 /* NumberLiteral */ && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */ && source.value === target.value))
           return true;
         if (isUnknownLikeUnionType(target))
           return true;
@@ -57512,24 +57491,7 @@ ${lanes.join("\n")}
       return isFinite(n) && (!roundTripOnly || "" + n === s);
     }
     function parseBigIntLiteralType(text) {
-      const negative = text.startsWith("-");
-      const base10Value = parsePseudoBigInt(`${negative ? text.slice(1) : text}n`);
-      return getBigIntLiteralType({ negative, base10Value });
-    }
-    function isValidBigIntString(s, roundTripOnly) {
-      if (s === "")
-        return false;
-      const scanner2 = createScanner(99 /* ESNext */, false);
-      let success = true;
-      scanner2.setOnError(() => success = false);
-      scanner2.setText(s + "n");
-      let result = scanner2.scan();
-      const negative = result === 40 /* MinusToken */;
-      if (negative) {
-        result = scanner2.scan();
-      }
-      const flags = scanner2.getTokenFlags();
-      return success && result === 9 /* BigIntLiteral */ && scanner2.getTextPos() === s.length + 1 && !(flags & 512 /* ContainsSeparator */) && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner2.getTokenValue()) }));
+      return getBigIntLiteralType(parseValidBigInt(text));
     }
     function isMemberOfStringMapping(source, target) {
       if (target.flags & (4 /* String */ | 1 /* Any */)) {
@@ -57626,7 +57588,7 @@ ${lanes.join("\n")}
         pos = p;
       }
     }
-    function inferTypes(inferences, originalSource, originalTarget, priority = 0, contravariant = false) {
+    function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
       let bivariant = false;
       let propagationType;
       let inferencePriority = 2048 /* MaxValue */;
@@ -60068,8 +60030,8 @@ ${lanes.join("\n")}
       }
       const parent2 = getRootDeclaration(symbol.valueDeclaration).parent;
       const links = getNodeLinks(parent2);
-      if (!(links.flags & 8388608 /* AssignmentsMarked */)) {
-        links.flags |= 8388608 /* AssignmentsMarked */;
+      if (!(links.flags & 524288 /* AssignmentsMarked */)) {
+        links.flags |= 524288 /* AssignmentsMarked */;
         if (!hasParentWithAssignmentsMarked(parent2)) {
           markNodeAssignments(parent2);
         }
@@ -60077,7 +60039,7 @@ ${lanes.join("\n")}
       return symbol.isAssigned || false;
     }
     function hasParentWithAssignmentsMarked(node) {
-      return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 8388608 /* AssignmentsMarked */));
+      return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 524288 /* AssignmentsMarked */));
     }
     function markNodeAssignments(node) {
       if (node.kind === 79 /* Identifier */) {
@@ -60156,11 +60118,11 @@ ${lanes.join("\n")}
           const parent2 = declaration.parent.parent;
           if (parent2.kind === 257 /* VariableDeclaration */ && getCombinedNodeFlags(declaration) & 2 /* Const */ || parent2.kind === 166 /* Parameter */) {
             const links = getNodeLinks(parent2);
-            if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
-              links.flags |= 268435456 /* InCheckIdentifier */;
+            if (!(links.flags & 16777216 /* InCheckIdentifier */)) {
+              links.flags |= 16777216 /* InCheckIdentifier */;
               const parentType = getTypeForBindingElementParent(parent2, 0 /* Normal */);
               const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
-              links.flags &= ~268435456 /* InCheckIdentifier */;
+              links.flags &= ~16777216 /* InCheckIdentifier */;
               if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent2.kind === 166 /* Parameter */ && isSymbolAssigned(symbol))) {
                 const pattern = declaration.parent;
                 const narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, void 0, location.flowNode);
@@ -60210,7 +60172,7 @@ ${lanes.join("\n")}
             error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
           }
         }
-        getNodeLinks(container).flags |= 8192 /* CaptureArguments */;
+        getNodeLinks(container).flags |= 512 /* CaptureArguments */;
         return getTypeOfSymbol(symbol);
       }
       if (shouldMarkIdentifierAliasReferenced(node)) {
@@ -60227,8 +60189,8 @@ ${lanes.join("\n")}
           let container = getContainingClass(node);
           while (container !== void 0) {
             if (container === declaration && container.name !== node) {
-              getNodeLinks(declaration).flags |= 16777216 /* ClassWithConstructorReference */;
-              getNodeLinks(node).flags |= 33554432 /* ConstructorReferenceInClass */;
+              getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
+              getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
               break;
             }
             container = getContainingClass(container);
@@ -60238,8 +60200,8 @@ ${lanes.join("\n")}
           while (container.kind !== 308 /* SourceFile */) {
             if (container.parent === declaration) {
               if (isPropertyDeclaration(container) && isStatic(container) || isClassStaticBlockDeclaration(container)) {
-                getNodeLinks(declaration).flags |= 16777216 /* ClassWithConstructorReference */;
-                getNodeLinks(node).flags |= 33554432 /* ConstructorReferenceInClass */;
+                getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
+                getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
               }
               break;
             }
@@ -60353,7 +60315,7 @@ ${lanes.join("\n")}
               const part = getPartOfForStatementContainingNode(node.parent, container);
               if (part) {
                 const links = getNodeLinks(part);
-                links.flags |= 131072 /* ContainsCapturedBlockScopeBinding */;
+                links.flags |= 8192 /* ContainsCapturedBlockScopeBinding */;
                 const capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
                 pushIfUnique(capturedBindings, symbol);
                 if (part === container.initializer) {
@@ -60363,19 +60325,19 @@ ${lanes.join("\n")}
             }
           }
           if (capturesBlockScopeBindingInLoopBody) {
-            getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
           }
         }
         if (isForStatement(container)) {
           const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
           if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
-            getNodeLinks(symbol.valueDeclaration).flags |= 4194304 /* NeedsLoopOutParameter */;
+            getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* NeedsLoopOutParameter */;
           }
         }
-        getNodeLinks(symbol.valueDeclaration).flags |= 524288 /* BlockScopedBindingInLoop */;
+        getNodeLinks(symbol.valueDeclaration).flags |= 32768 /* BlockScopedBindingInLoop */;
       }
       if (isCaptured) {
-        getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* CapturedBlockScopedBinding */;
+        getNodeLinks(symbol.valueDeclaration).flags |= 16384 /* CapturedBlockScopedBinding */;
       }
     }
     function isBindingCapturedByNode(node, decl) {
@@ -60592,23 +60554,23 @@ ${lanes.join("\n")}
         checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
       }
       if (isStatic(container) || isCallExpression2) {
-        nodeCheckFlag = 512 /* SuperStatic */;
+        nodeCheckFlag = 32 /* SuperStatic */;
         if (!isCallExpression2 && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && (isPropertyDeclaration(container) || isClassStaticBlockDeclaration(container))) {
           forEachEnclosingBlockScopeContainer(node.parent, (current) => {
             if (!isSourceFile(current) || isExternalOrCommonJsModule(current)) {
-              getNodeLinks(current).flags |= 134217728 /* ContainsSuperPropertyInStaticInitializer */;
+              getNodeLinks(current).flags |= 8388608 /* ContainsSuperPropertyInStaticInitializer */;
             }
           });
         }
       } else {
-        nodeCheckFlag = 256 /* SuperInstance */;
+        nodeCheckFlag = 16 /* SuperInstance */;
       }
       getNodeLinks(node).flags |= nodeCheckFlag;
       if (container.kind === 171 /* MethodDeclaration */ && inAsyncFunction) {
         if (isSuperProperty(node.parent) && isAssignmentTarget(node.parent)) {
-          getNodeLinks(container).flags |= 4096 /* MethodWithSuperPropertyAssignmentInAsync */;
+          getNodeLinks(container).flags |= 256 /* MethodWithSuperPropertyAssignmentInAsync */;
         } else {
-          getNodeLinks(container).flags |= 2048 /* MethodWithSuperPropertyAccessInAsync */;
+          getNodeLinks(container).flags |= 128 /* MethodWithSuperPropertyAccessInAsync */;
         }
       }
       if (needToCaptureLexicalThis) {
@@ -60636,7 +60598,7 @@ ${lanes.join("\n")}
         error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
         return errorType;
       }
-      return nodeCheckFlag === 512 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
+      return nodeCheckFlag === 32 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
       function isLegalUsageOfSuperExpression(container2) {
         if (!container2) {
           return false;
@@ -61651,9 +61613,9 @@ ${lanes.join("\n")}
           const container = getEnclosingBlockScopeContainer(node.parent.parent);
           const enclosingIterationStatement = getEnclosingIterationStatement(container);
           if (enclosingIterationStatement) {
-            getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
-            getNodeLinks(node).flags |= 524288 /* BlockScopedBindingInLoop */;
-            getNodeLinks(node.parent.parent).flags |= 524288 /* BlockScopedBindingInLoop */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+            getNodeLinks(node).flags |= 32768 /* BlockScopedBindingInLoop */;
+            getNodeLinks(node.parent.parent).flags |= 32768 /* BlockScopedBindingInLoop */;
           }
         }
         if (links.resolvedType.flags & 98304 /* Nullable */ || !isTypeAssignableToKind(links.resolvedType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */) && !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
@@ -65640,10 +65602,10 @@ ${lanes.join("\n")}
     }
     function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
       const links = getNodeLinks(node);
-      if (!(links.flags & 1024 /* ContextChecked */)) {
+      if (!(links.flags & 64 /* ContextChecked */)) {
         const contextualSignature = getContextualSignature(node);
-        if (!(links.flags & 1024 /* ContextChecked */)) {
-          links.flags |= 1024 /* ContextChecked */;
+        if (!(links.flags & 64 /* ContextChecked */)) {
+          links.flags |= 64 /* ContextChecked */;
           const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0 /* Call */));
           if (!signature) {
             return;
@@ -67633,13 +67595,13 @@ ${lanes.join("\n")}
     function setNodeLinksForPrivateIdentifierScope(node) {
       if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
         for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
-          getNodeLinks(lexicalScope).flags |= 67108864 /* ContainsClassWithPrivateIdentifiers */;
+          getNodeLinks(lexicalScope).flags |= 4194304 /* ContainsClassWithPrivateIdentifiers */;
         }
         if (isClassExpression(node.parent)) {
           const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
           if (enclosingIterationStatement) {
-            getNodeLinks(node.name).flags |= 524288 /* BlockScopedBindingInLoop */;
-            getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+            getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
           }
         }
       }
@@ -69234,7 +69196,7 @@ ${lanes.join("\n")}
     }
     function checkWeakMapSetCollision(node) {
       const enclosingBlockScope = getEnclosingBlockScopeContainer(node);
-      if (getNodeCheckFlags(enclosingBlockScope) & 67108864 /* ContainsClassWithPrivateIdentifiers */) {
+      if (getNodeCheckFlags(enclosingBlockScope) & 4194304 /* ContainsClassWithPrivateIdentifiers */) {
         Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name) && typeof node.name.escapedText === "string", "The target of a WeakMap/WeakSet collision check should be an identifier");
         errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, node.name.escapedText);
       }
@@ -69248,18 +69210,18 @@ ${lanes.join("\n")}
       let hasCollision = false;
       if (isClassExpression(node)) {
         for (const member of node.members) {
-          if (getNodeCheckFlags(member) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+          if (getNodeCheckFlags(member) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
             hasCollision = true;
             break;
           }
         }
       } else if (isFunctionExpression(node)) {
-        if (getNodeCheckFlags(node) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+        if (getNodeCheckFlags(node) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
           hasCollision = true;
         }
       } else {
         const container = getEnclosingBlockScopeContainer(node);
-        if (container && getNodeCheckFlags(container) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+        if (container && getNodeCheckFlags(container) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
           hasCollision = true;
         }
       }
@@ -70474,8 +70436,9 @@ ${lanes.join("\n")}
       });
       const containsArguments = containsArgumentsReference(node);
       if (containsArguments) {
-        const lastJSDocParam = lastOrUndefined(jsdocParameters);
-        if (isJs && lastJSDocParam && isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
+        const lastJSDocParamIndex = jsdocParameters.length - 1;
+        const lastJSDocParam = jsdocParameters[lastJSDocParamIndex];
+        if (isJs && lastJSDocParam && isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !excludedParameters.has(lastJSDocParamIndex) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
           error(lastJSDocParam.name, Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, idText(lastJSDocParam.name));
         }
       } else {
@@ -71143,8 +71106,8 @@ ${lanes.join("\n")}
     }
     function computeEnumMemberValues(node) {
       const nodeLinks2 = getNodeLinks(node);
-      if (!(nodeLinks2.flags & 16384 /* EnumValuesComputed */)) {
-        nodeLinks2.flags |= 16384 /* EnumValuesComputed */;
+      if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
+        nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
         let autoValue = 0;
         for (const member of node.members) {
           const value = computeMemberValue(member, autoValue);
@@ -71420,7 +71383,7 @@ ${lanes.join("\n")}
           }
           const mergedClass = getDeclarationOfKind(symbol, 260 /* ClassDeclaration */);
           if (mergedClass && inSameLexicalScope(node, mergedClass)) {
-            getNodeLinks(node).flags |= 32768 /* LexicalModuleMergesWithClass */;
+            getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
           }
         }
         if (isAmbientExternalModule) {
@@ -73051,8 +73014,8 @@ ${lanes.join("\n")}
             const nodeLinks2 = getNodeLinks(symbol.valueDeclaration);
             if (resolveName(container.parent, symbol.escapedName, 111551 /* Value */, void 0, void 0, false)) {
               links.isDeclarationWithCollidingName = true;
-            } else if (nodeLinks2.flags & 262144 /* CapturedBlockScopedBinding */) {
-              const isDeclaredInLoop = nodeLinks2.flags & 524288 /* BlockScopedBindingInLoop */;
+            } else if (nodeLinks2.flags & 16384 /* CapturedBlockScopedBinding */) {
+              const isDeclaredInLoop = nodeLinks2.flags & 32768 /* BlockScopedBindingInLoop */;
               const inLoopInitializer = isIterationStatement(container, false);
               const inLoopBodyBlock = container.kind === 238 /* Block */ && isIterationStatement(container.parent, false);
               links.isDeclarationWithCollidingName = !isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || !inLoopInitializer && !inLoopBodyBlock);
@@ -75354,6 +75317,7 @@ ${lanes.join("\n")}
         return CheckMode3;
       })(CheckMode || {});
       SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
+        SignatureCheckMode3[SignatureCheckMode3["None"] = 0] = "None";
         SignatureCheckMode3[SignatureCheckMode3["BivariantCallback"] = 1] = "BivariantCallback";
         SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
         SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
@@ -76627,10 +76591,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) {
@@ -80358,12 +80322,12 @@ ${lanes.join("\n")}
     function visitClassExpressionInNewClassLexicalEnvironment(node, facts) {
       const isDecoratedClassDeclaration = !!(facts & 1 /* ClassWasDecorated */);
       const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
-      const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 16777216 /* ClassWithConstructorReference */;
+      const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */;
       let temp;
       function createClassTempVar() {
         const classCheckFlags = resolver.getNodeCheckFlags(node);
-        const isClassWithConstructorReference2 = classCheckFlags & 16777216 /* ClassWithConstructorReference */;
-        const requiresBlockScopedVar = classCheckFlags & 524288 /* BlockScopedBindingInLoop */;
+        const isClassWithConstructorReference2 = classCheckFlags & 1048576 /* ClassWithConstructorReference */;
+        const requiresBlockScopedVar = classCheckFlags & 32768 /* BlockScopedBindingInLoop */;
         return factory2.createTempVariable(requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration, !!isClassWithConstructorReference2);
       }
       if (facts & 2 /* NeedsClassConstructorReference */) {
@@ -80876,7 +80840,7 @@ ${lanes.join("\n")}
     }
     function trySubstituteClassAlias(node) {
       if (enabledSubstitutions & 1 /* ClassAliases */) {
-        if (resolver.getNodeCheckFlags(node) & 33554432 /* ConstructorReferenceInClass */) {
+        if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
           const declaration = resolver.getReferencedValueDeclaration(node);
           if (declaration) {
             const classAlias = classAliases[declaration.id];
@@ -80899,7 +80863,7 @@ ${lanes.join("\n")}
         const alreadyTransformed = isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
         if (!alreadyTransformed && !inlinable && shouldHoist) {
           const generatedName = factory2.getGeneratedNameForNode(name);
-          if (resolver.getNodeCheckFlags(name) & 524288 /* BlockScopedBindingInLoop */) {
+          if (resolver.getNodeCheckFlags(name) & 32768 /* BlockScopedBindingInLoop */) {
             addBlockScopedVariable(generatedName);
           } else {
             hoistVariableDeclaration(generatedName);
@@ -81048,7 +81012,7 @@ ${lanes.join("\n")}
       const { className } = getPrivateIdentifierEnvironment();
       const prefix = className ? { prefix: "_", node: className, suffix: "_" } : "_";
       const identifier = typeof name === "object" ? factory2.getGeneratedNameForNode(name, 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */, prefix, suffix) : typeof name === "string" ? factory2.createUniqueName(name, 16 /* Optimistic */, prefix, suffix) : factory2.createTempVariable(void 0, true, prefix, suffix);
-      if (resolver.getNodeCheckFlags(node) & 524288 /* BlockScopedBindingInLoop */) {
+      if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
         addBlockScopedVariable(identifier);
       } else {
         hoistVariableDeclaration(identifier);
@@ -81932,7 +81896,7 @@ ${lanes.join("\n")}
       }
     }
     function getClassAliasIfNeeded(node) {
-      if (resolver.getNodeCheckFlags(node) & 16777216 /* ClassWithConstructorReference */) {
+      if (resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */) {
         enableSubstitutionForClassAliases();
         const classAlias = factory2.createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? idText(node.name) : "default");
         classAliases[getOriginalNodeId(node)] = classAlias;
@@ -81966,7 +81930,7 @@ ${lanes.join("\n")}
     }
     function trySubstituteClassAlias(node) {
       if (classAliases) {
-        if (resolver.getNodeCheckFlags(node) & 33554432 /* ConstructorReferenceInClass */) {
+        if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
           const declaration = resolver.getReferencedValueDeclaration(node);
           if (declaration) {
             const classAlias = classAliases[declaration.id];
@@ -82007,7 +81971,7 @@ ${lanes.join("\n")}
     let capturedSuperProperties;
     let hasSuperElementAccess;
     const substitutedSuperAccessors = [];
-    let contextFlags = 0;
+    let contextFlags = 0 /* None */;
     const previousOnEmitNode = context.onEmitNode;
     const previousOnSubstituteNode = context.onSubstituteNode;
     context.onEmitNode = onEmitNode;
@@ -82334,7 +82298,7 @@ ${lanes.join("\n")}
       hasSuperElementAccess = false;
       let updated = visitFunctionBody(node.body, visitor, context);
       const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
-      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
+      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
         if (capturedSuperProperties.size) {
@@ -82345,9 +82309,9 @@ ${lanes.join("\n")}
           updated = factory2.updateBlock(updated, statements);
         }
         if (hasSuperElementAccess) {
-          if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+          if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
             addEmitHelper(updated, advancedAsyncSuperHelper);
-          } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+          } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
             addEmitHelper(updated, asyncSuperHelper);
           }
         }
@@ -82362,7 +82326,7 @@ ${lanes.join("\n")}
       const nodeType = original.type;
       const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
       const isArrowFunction2 = node.kind === 216 /* ArrowFunction */;
-      const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192 /* CaptureArguments */) !== 0;
+      const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
       const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
       enclosingFunctionParameterNames = /* @__PURE__ */ new Set();
       for (const parameter of node.parameters) {
@@ -82389,7 +82353,7 @@ ${lanes.join("\n")}
           )
         );
         insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
-        const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */);
+        const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
         if (emitSuperHelpers) {
           enableSubstitutionForAsyncMethodsWithSuper();
           if (capturedSuperProperties.size) {
@@ -82401,9 +82365,9 @@ ${lanes.join("\n")}
         const block = factory2.createBlock(statements, true);
         setTextRange(block, node.body);
         if (emitSuperHelpers && hasSuperElementAccess) {
-          if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+          if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
             addEmitHelper(block, advancedAsyncSuperHelper);
-          } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+          } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
             addEmitHelper(block, asyncSuperHelper);
           }
         }
@@ -82463,7 +82427,7 @@ ${lanes.join("\n")}
     }
     function onEmitNode(hint, node, emitCallback) {
       if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-        const superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* MethodWithSuperPropertyAccessInAsync */ | 4096 /* MethodWithSuperPropertyAssignmentInAsync */);
+        const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
         if (superContainerFlags !== enclosingSuperContainerFlags) {
           const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
           enclosingSuperContainerFlags = superContainerFlags;
@@ -82539,7 +82503,7 @@ ${lanes.join("\n")}
       return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
     }
     function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-      if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         return setTextRange(
           factory2.createPropertyAccessExpression(
             factory2.createCallExpression(
@@ -82564,7 +82528,7 @@ ${lanes.join("\n")}
     }
   }
   function createSuperAccessVariableStatement(factory2, resolver, node, names) {
-    const hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
+    const hasBinding = (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
     const accessors = [];
     names.forEach((_, key) => {
       const name = unescapeLeadingUnderscores(key);
@@ -83508,7 +83472,7 @@ ${lanes.join("\n")}
           !!(hierarchyFacts & 1 /* HasLexicalThis */)
         )
       );
-      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */);
+      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
         const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
@@ -83519,9 +83483,9 @@ ${lanes.join("\n")}
       insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
       const block = factory2.updateBlock(node.body, statements);
       if (emitSuperHelpers && hasSuperElementAccess) {
-        if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+        if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
           addEmitHelper(block, advancedAsyncSuperHelper);
-        } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+        } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
           addEmitHelper(block, asyncSuperHelper);
         }
       }
@@ -83631,7 +83595,7 @@ ${lanes.join("\n")}
     }
     function onEmitNode(hint, node, emitCallback) {
       if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-        const superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* MethodWithSuperPropertyAccessInAsync */ | 4096 /* MethodWithSuperPropertyAssignmentInAsync */);
+        const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
         if (superContainerFlags !== enclosingSuperContainerFlags) {
           const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
           enclosingSuperContainerFlags = superContainerFlags;
@@ -83707,7 +83671,7 @@ ${lanes.join("\n")}
       return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
     }
     function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-      if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         return setTextRange(
           factory2.createPropertyAccessExpression(
             factory2.createCallExpression(
@@ -86106,8 +86070,8 @@ ${lanes.join("\n")}
     }
     function shouldEmitExplicitInitializerForLetDeclaration(node) {
       const flags = resolver.getNodeCheckFlags(node);
-      const isCapturedInFunction = flags & 262144 /* CapturedBlockScopedBinding */;
-      const isDeclaredInLoop = flags & 524288 /* BlockScopedBindingInLoop */;
+      const isCapturedInFunction = flags & 16384 /* CapturedBlockScopedBinding */;
+      const isDeclaredInLoop = flags & 32768 /* BlockScopedBindingInLoop */;
       const emittedAsTopLevel = (hierarchyFacts & 64 /* TopLevel */) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512 /* IterationStatementBlock */) !== 0;
       const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096 /* ForInOrForOfStatement */) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 /* ForStatement */ | 4096 /* ForInOrForOfStatement */)) === 0);
       return emitExplicitInitializer;
@@ -86468,7 +86432,7 @@ ${lanes.join("\n")}
       return factory2.inlineExpressions(expressions);
     }
     function shouldConvertPartOfIterationStatement(node) {
-      return (resolver.getNodeCheckFlags(node) & 131072 /* ContainsCapturedBlockScopeBinding */) !== 0;
+      return (resolver.getNodeCheckFlags(node) & 8192 /* ContainsCapturedBlockScopeBinding */) !== 0;
     }
     function shouldConvertInitializerOfForStatement(node) {
       return isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer);
@@ -86483,7 +86447,7 @@ ${lanes.join("\n")}
       return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
     }
     function shouldConvertBodyOfIterationStatement(node) {
-      return (resolver.getNodeCheckFlags(node) & 65536 /* LoopWithCapturedBlockScopedBinding */) !== 0;
+      return (resolver.getNodeCheckFlags(node) & 4096 /* LoopWithCapturedBlockScopedBinding */) !== 0;
     }
     function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) {
       if (!state.hoistedLocalVariables) {
@@ -86944,10 +86908,10 @@ ${lanes.join("\n")}
       } else {
         loopParameters.push(factory2.createParameterDeclaration(void 0, void 0, name));
         const checkFlags = resolver.getNodeCheckFlags(decl);
-        if (checkFlags & 4194304 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
+        if (checkFlags & 262144 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
           const outParamName = factory2.createUniqueName("out_" + idText(name));
-          let flags = 0;
-          if (checkFlags & 4194304 /* NeedsLoopOutParameter */) {
+          let flags = 0 /* None */;
+          if (checkFlags & 262144 /* NeedsLoopOutParameter */) {
             flags |= 1 /* Body */;
           }
           if (isForStatement(container)) {
@@ -94939,7 +94903,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 +94911,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 +95015,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 +95024,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 +95109,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 +95122,7 @@ ${lanes.join("\n")}
       getSourceFileFromReference: returnUndefined,
       redirectTargetsMap: createMultiMap(),
       getFileIncludeReasons: notImplemented,
-      createHash
+      createHash: maybeBind(host, host.createHash)
     };
     emitFiles(
       notImplementedResolver,
@@ -103354,7 +103317,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 +103325,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 +103364,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 +103394,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 +103407,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 +103549,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 +103565,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 +103609,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 +103655,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 +103715,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 +103731,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 +103774,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 +103790,6 @@ ${lanes.join("\n")}
               state,
               affectedFile,
               cancellationToken,
-              computeHash,
-              getCanonicalFileName,
               host
             );
             return affectedFile;
@@ -103854,8 +103817,7 @@ ${lanes.join("\n")}
         program,
         nextKey.value,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName
+        host
       );
       state.currentChangedFilePath = nextKey.value;
       state.affectedFilesIndex = 0;
@@ -103907,7 +103869,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 +103878,7 @@ ${lanes.join("\n")}
         Debug.checkDefined(state.program),
         affectedFile,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName
+        host
       );
       return;
     }
@@ -103927,12 +103888,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 +103902,7 @@ ${lanes.join("\n")}
           program,
           sourceFile,
           cancellationToken,
-          computeHash,
-          getCanonicalFileName,
+          host,
           !host.disableUseFileVersionAsSignature
         );
         if (getEmitDeclarations(state.compilerOptions)) {
@@ -103966,7 +103924,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 +103932,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 +103951,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 +103963,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 +103973,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 +103999,6 @@ ${lanes.join("\n")}
         state,
         referencingFilePath,
         cancellationToken,
-        computeHash,
-        getCanonicalFileName,
         host
       )
     );
@@ -104077,9 +104027,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 +104249,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 +104259,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 +104268,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 +104286,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 +104321,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 +104395,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 +104442,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 +104498,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 +116367,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
@@ -129579,6 +129535,13 @@ ${lanes.join("\n")}
     if (!isChecked) {
       getJSCompletionEntries(sourceFile, location.pos, uniqueNames, getEmitScriptTarget(compilerOptions), entries);
     }
+    let caseBlock;
+    if (preferences.includeCompletionsWithInsertText && contextToken && (caseBlock = findAncestor(contextToken, isCaseBlock))) {
+      const cases = getExhaustiveCaseSnippets(caseBlock, sourceFile, preferences, compilerOptions, host, program, formatContext);
+      if (cases) {
+        entries.push(cases.entry);
+      }
+    }
     return {
       flags: completionData.flags,
       isGlobalCompletion: isInSnippetScope,
@@ -129592,6 +129555,190 @@ ${lanes.join("\n")}
   function isCheckedFile(sourceFile, compilerOptions) {
     return !isSourceFileJS(sourceFile) || !!isCheckJsEnabledForFile(sourceFile, compilerOptions);
   }
+  function getExhaustiveCaseSnippets(caseBlock, sourceFile, preferences, options, host, program, formatContext) {
+    const clauses = caseBlock.clauses;
+    const checker = program.getTypeChecker();
+    const switchType = checker.getTypeAtLocation(caseBlock.parent.expression);
+    if (switchType && switchType.isUnion() && every(switchType.types, (type) => type.isLiteral())) {
+      const tracker = newCaseClauseTracker(checker, clauses);
+      const target = getEmitScriptTarget(options);
+      const quotePreference = getQuotePreference(sourceFile, preferences);
+      const importAdder = ts_codefix_exports.createImportAdder(sourceFile, program, preferences, host);
+      const elements = [];
+      for (const type of switchType.types) {
+        if (type.flags & 1024 /* EnumLiteral */) {
+          Debug.assert(type.symbol, "An enum member type should have a symbol");
+          Debug.assert(type.symbol.parent, "An enum member type should have a parent symbol (the enum symbol)");
+          const enumValue = type.symbol.valueDeclaration && checker.getConstantValue(type.symbol.valueDeclaration);
+          if (enumValue !== void 0) {
+            if (tracker.hasValue(enumValue)) {
+              continue;
+            }
+            tracker.addValue(enumValue);
+          }
+          const typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(checker, importAdder, type, caseBlock, target);
+          if (!typeNode) {
+            return void 0;
+          }
+          const expr = typeNodeToExpression(typeNode, target, quotePreference);
+          if (!expr) {
+            return void 0;
+          }
+          elements.push(expr);
+        } else if (!tracker.hasValue(type.value)) {
+          switch (typeof type.value) {
+            case "object":
+              elements.push(factory.createBigIntLiteral(type.value));
+              break;
+            case "number":
+              elements.push(factory.createNumericLiteral(type.value));
+              break;
+            case "string":
+              elements.push(factory.createStringLiteral(type.value));
+              break;
+          }
+        }
+      }
+      if (elements.length === 0) {
+        return void 0;
+      }
+      const newClauses = map(elements, (element) => {
+        return factory.createCaseClause(element, []);
+      });
+      const printer = createSnippetPrinter({
+        removeComments: true,
+        module: options.module,
+        target: options.target,
+        newLine: getNewLineKind(getNewLineCharacter(options, maybeBind(host, host.getNewLine)))
+      });
+      const insertText = formatContext ? printer.printAndFormatSnippetList(
+        1 /* MultiLine */ | 131072 /* NoTrailingNewLine */,
+        factory.createNodeArray(newClauses),
+        sourceFile,
+        formatContext
+      ) : printer.printSnippetList(
+        1 /* MultiLine */ | 131072 /* NoTrailingNewLine */,
+        factory.createNodeArray(newClauses),
+        sourceFile
+      );
+      const firstClause = printer.printSnippetList(0 /* SingleLine */, factory.createNodeArray([first(newClauses)]), sourceFile);
+      return {
+        entry: {
+          name: `${firstClause} ...`,
+          kind: "" /* unknown */,
+          sortText: SortText.GlobalsOrKeywords,
+          insertText,
+          hasAction: importAdder.hasFixes() || void 0,
+          source: "SwitchCases/" /* SwitchCases */
+        },
+        importAdder
+      };
+    }
+    return void 0;
+  }
+  function newCaseClauseTracker(checker, clauses) {
+    const existingStrings = /* @__PURE__ */ new Set();
+    const existingNumbers = /* @__PURE__ */ new Set();
+    const existingBigInts = /* @__PURE__ */ new Set();
+    for (const clause of clauses) {
+      if (!isDefaultClause(clause)) {
+        if (isLiteralExpression(clause.expression)) {
+          const expression = clause.expression;
+          switch (expression.kind) {
+            case 14 /* NoSubstitutionTemplateLiteral */:
+            case 10 /* StringLiteral */:
+              existingStrings.add(expression.text);
+              break;
+            case 8 /* NumericLiteral */:
+              existingNumbers.add(parseInt(expression.text));
+              break;
+            case 9 /* BigIntLiteral */:
+              const parsedBigInt = parseBigInt(endsWith(expression.text, "n") ? expression.text.slice(0, -1) : expression.text);
+              if (parsedBigInt) {
+                existingBigInts.add(pseudoBigIntToString(parsedBigInt));
+              }
+              break;
+          }
+        } else {
+          const symbol = checker.getSymbolAtLocation(clause.expression);
+          if (symbol && symbol.valueDeclaration && isEnumMember(symbol.valueDeclaration)) {
+            const enumValue = checker.getConstantValue(symbol.valueDeclaration);
+            if (enumValue !== void 0) {
+              addValue(enumValue);
+            }
+          }
+        }
+      }
+    }
+    return {
+      addValue,
+      hasValue
+    };
+    function addValue(value) {
+      switch (typeof value) {
+        case "string":
+          existingStrings.add(value);
+          break;
+        case "number":
+          existingNumbers.add(value);
+      }
+    }
+    function hasValue(value) {
+      switch (typeof value) {
+        case "string":
+          return existingStrings.has(value);
+        case "number":
+          return existingNumbers.has(value);
+        case "object":
+          return existingBigInts.has(pseudoBigIntToString(value));
+      }
+    }
+  }
+  function typeNodeToExpression(typeNode, languageVersion, quotePreference) {
+    switch (typeNode.kind) {
+      case 180 /* TypeReference */:
+        const typeName = typeNode.typeName;
+        return entityNameToExpression(typeName, languageVersion, quotePreference);
+      case 196 /* IndexedAccessType */:
+        const objectExpression = typeNodeToExpression(typeNode.objectType, languageVersion, quotePreference);
+        const indexExpression = typeNodeToExpression(typeNode.indexType, languageVersion, quotePreference);
+        return objectExpression && indexExpression && factory.createElementAccessExpression(objectExpression, indexExpression);
+      case 198 /* LiteralType */:
+        const literal = typeNode.literal;
+        switch (literal.kind) {
+          case 10 /* StringLiteral */:
+            return factory.createStringLiteral(literal.text, quotePreference === 0 /* Single */);
+          case 8 /* NumericLiteral */:
+            return factory.createNumericLiteral(literal.text, literal.numericLiteralFlags);
+        }
+        return void 0;
+      case 193 /* ParenthesizedType */:
+        const exp = typeNodeToExpression(typeNode.type, languageVersion, quotePreference);
+        return exp && (isIdentifier(exp) ? exp : factory.createParenthesizedExpression(exp));
+      case 183 /* TypeQuery */:
+        return entityNameToExpression(typeNode.exprName, languageVersion, quotePreference);
+      case 202 /* ImportType */:
+        Debug.fail(`We should not get an import type after calling 'codefix.typeToAutoImportableTypeNode'.`);
+    }
+    return void 0;
+  }
+  function entityNameToExpression(entityName, languageVersion, quotePreference) {
+    if (isIdentifier(entityName)) {
+      return entityName;
+    }
+    const realName = unescapeLeadingUnderscores(entityName.right.escapedText);
+    if (canUsePropertyAccess(realName, languageVersion)) {
+      return factory.createPropertyAccessExpression(
+        entityNameToExpression(entityName.left, languageVersion, quotePreference),
+        realName
+      );
+    } else {
+      return factory.createElementAccessExpression(
+        entityNameToExpression(entityName.left, languageVersion, quotePreference),
+        factory.createStringLiteral(realName, quotePreference === 0 /* Single */)
+      );
+    }
+  }
   function isMemberCompletionKind(kind) {
     switch (kind) {
       case CompletionKind.ObjectPropertyDeclaration:
@@ -130250,6 +130397,9 @@ ${lanes.join("\n")}
     return entries;
   }
   function getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences) {
+    if (entryId.source === "SwitchCases/" /* SwitchCases */) {
+      return { type: "cases" };
+    }
     if (entryId.data) {
       const autoImport = getAutoImportSymbolFromCompletionEntryData(entryId.name, entryId.data, program, host);
       if (autoImport) {
@@ -130288,9 +130438,9 @@ ${lanes.join("\n")}
     const typeChecker = program.getTypeChecker();
     const compilerOptions = program.getCompilerOptions();
     const { name, source, data } = entryId;
-    const contextToken = findPrecedingToken(position, sourceFile);
-    if (isInString(sourceFile, position, contextToken)) {
-      return ts_Completions_StringCompletions_exports.getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, typeChecker, compilerOptions, host, cancellationToken, preferences);
+    const { previousToken, contextToken } = getRelevantTokens(position, sourceFile);
+    if (isInString(sourceFile, position, previousToken)) {
+      return ts_Completions_StringCompletions_exports.getStringLiteralCompletionDetails(name, sourceFile, position, previousToken, typeChecker, compilerOptions, host, cancellationToken, preferences);
     }
     const symbolCompletion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences);
     switch (symbolCompletion.type) {
@@ -130310,14 +130460,40 @@ ${lanes.join("\n")}
         }
       }
       case "symbol": {
-        const { symbol, location, contextToken: contextToken2, origin, previousToken } = symbolCompletion;
-        const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken2, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source, cancellationToken);
+        const { symbol, location, contextToken: contextToken2, origin, previousToken: previousToken2 } = symbolCompletion;
+        const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken2, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken2, formatContext, preferences, data, source, cancellationToken);
         return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay);
       }
       case "literal": {
         const { literal } = symbolCompletion;
         return createSimpleDetails(completionNameForLiteral(sourceFile, preferences, literal), "string" /* string */, typeof literal === "string" ? 8 /* stringLiteral */ : 7 /* numericLiteral */);
       }
+      case "cases": {
+        const { entry, importAdder } = getExhaustiveCaseSnippets(
+          contextToken.parent,
+          sourceFile,
+          preferences,
+          program.getCompilerOptions(),
+          host,
+          program,
+          void 0
+        );
+        const changes = ts_textChanges_exports.ChangeTracker.with(
+          { host, formatContext, preferences },
+          importAdder.writeFixes
+        );
+        return {
+          name: entry.name,
+          kind: "" /* unknown */,
+          kindModifiers: "",
+          displayParts: [],
+          sourceDisplay: void 0,
+          codeActions: [{
+            changes,
+            description: diagnosticToString([Diagnostics.Includes_imports_of_types_referenced_by_0, name])
+          }]
+        };
+      }
       case "none":
         return allKeywordsCompletions().some((c) => c.name === name) ? createSimpleDetails(name, "keyword" /* keyword */, 5 /* keyword */) : void 0;
       default:
@@ -132204,6 +132380,7 @@ ${lanes.join("\n")}
         CompletionSource2["ClassMemberSnippet"] = "ClassMemberSnippet/";
         CompletionSource2["TypeOnlyAlias"] = "TypeOnlyAlias/";
         CompletionSource2["ObjectLiteralMethodSnippet"] = "ObjectLiteralMethodSnippet/";
+        CompletionSource2["SwitchCases"] = "SwitchCases/";
         return CompletionSource2;
       })(CompletionSource || {});
       SymbolOriginInfoKind = /* @__PURE__ */ ((SymbolOriginInfoKind2) => {
@@ -144672,6 +144849,7 @@ ${options.prefix}` : "\n" : options.prefix
       init_ts4();
       anyContext = emptyArray;
       RuleAction = /* @__PURE__ */ ((RuleAction2) => {
+        RuleAction2[RuleAction2["None"] = 0] = "None";
         RuleAction2[RuleAction2["StopProcessingSpaceActions"] = 1] = "StopProcessingSpaceActions";
         RuleAction2[RuleAction2["StopProcessingTokenActions"] = 2] = "StopProcessingTokenActions";
         RuleAction2[RuleAction2["InsertSpace"] = 4] = "InsertSpace";
@@ -145327,7 +145505,7 @@ ${options.prefix}` : "\n" : options.prefix
     return rulesMapCache;
   }
   function getRuleActionExclusion(ruleAction) {
-    let mask2 = 0;
+    let mask2 = 0 /* None */;
     if (ruleAction & 1 /* StopProcessingSpaceActions */) {
       mask2 |= 28 /* ModifySpaceAction */;
     }
@@ -146916,6 +147094,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 +147158,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 +147199,7 @@ ${options.prefix}` : "\n" : options.prefix
     "src/deprecatedCompat/deprecations.ts"() {
       "use strict";
       init_ts5();
+      init_deprecate();
     }
   });
 
@@ -146973,337 +147209,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 +147555,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 +147571,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 +147580,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 +147589,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 +147607,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 +147628,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 +147716,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 +147733,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",
@@ -148409,6 +148648,7 @@ ${options.prefix}` : "\n" : options.prefix
     canHaveModifiers: () => canHaveModifiers,
     canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
     canProduceDiagnostics: () => canProduceDiagnostics,
+    canUsePropertyAccess: () => canUsePropertyAccess,
     canWatchDirectoryOrFile: () => canWatchDirectoryOrFile,
     cartesianProduct: () => cartesianProduct,
     cast: () => cast,
@@ -150084,6 +150324,7 @@ ${options.prefix}` : "\n" : options.prefix
     isUnparsedSource: () => isUnparsedSource,
     isUnparsedTextLike: () => isUnparsedTextLike,
     isUrl: () => isUrl,
+    isValidBigIntString: () => isValidBigIntString,
     isValidESSymbolDeclaration: () => isValidESSymbolDeclaration,
     isValidTypeOnlyAliasUseSite: () => isValidTypeOnlyAliasUseSite,
     isValueSignatureDeclaration: () => isValueSignatureDeclaration,
@@ -150215,6 +150456,7 @@ ${options.prefix}` : "\n" : options.prefix
     parameterIsThisKeyword: () => parameterIsThisKeyword,
     parameterNamePart: () => parameterNamePart,
     parseBaseNodeFactory: () => parseBaseNodeFactory,
+    parseBigInt: () => parseBigInt,
     parseBuildCommand: () => parseBuildCommand,
     parseCommandLine: () => parseCommandLine,
     parseCommandLineWorker: () => parseCommandLineWorker,
@@ -150233,6 +150475,7 @@ ${options.prefix}` : "\n" : options.prefix
     parseNodeModuleFromPath: () => parseNodeModuleFromPath,
     parsePackageName: () => parsePackageName,
     parsePseudoBigInt: () => parsePseudoBigInt,
+    parseValidBigInt: () => parseValidBigInt,
     patchWriteFileEnsuringDirectory: () => patchWriteFileEnsuringDirectory,
     pathContainsNodeModules: () => pathContainsNodeModules,
     pathIsAbsolute: () => pathIsAbsolute,
@@ -150413,6 +150656,7 @@ ${options.prefix}` : "\n" : options.prefix
     supportedLocaleDirectories: () => supportedLocaleDirectories,
     supportedTSExtensions: () => supportedTSExtensions,
     supportedTSExtensionsFlat: () => supportedTSExtensionsFlat,
+    supportedTSImplementationExtensions: () => supportedTSImplementationExtensions,
     suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia,
     suppressLeadingTrivia: () => suppressLeadingTrivia,
     suppressTrailingTrivia: () => suppressTrailingTrivia,