typescript 5.6.0-dev.20240808 → 5.6.0-dev.20240810

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240808`;
+var version = `${versionMajorMinor}.0-dev.20240810`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5527,6 +5527,13 @@ function changeAnyExtension(path, ext, extensions, ignoreCase) {
   const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
   return pathext ? path.slice(0, path.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path;
 }
+function changeFullExtension(path, newExtension) {
+  const declarationExtension = getDeclarationFileExtension(path);
+  if (declarationExtension) {
+    return path.slice(0, path.length - declarationExtension.length) + (startsWith(newExtension, ".") ? newExtension : "." + newExtension);
+  }
+  return changeAnyExtension(path, newExtension);
+}
 var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
 function comparePathsWorker(a, b, componentComparer) {
   if (a === b) return 0 /* EqualTo */;
@@ -18255,6 +18262,9 @@ function hasJSFileExtension(fileName) {
 function hasTSFileExtension(fileName) {
   return some(supportedTSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
 }
+function hasImplementationTSFileExtension(fileName) {
+  return some(supportedTSImplementationExtensions, (extension) => fileExtensionIs(fileName, extension)) && !isDeclarationFileName(fileName);
+}
 function usesExtensionsOnImports({ imports }, hasExtension2 = or(hasJSFileExtension, hasTSFileExtension)) {
   return firstDefined(imports, ({ text }) => pathIsRelative(text) && !fileExtensionIsOneOf(text, extensionsNotSupportingExtensionlessResolution) ? hasExtension2(text) : void 0) || false;
 }
@@ -21271,7 +21281,11 @@ function createNodeFactory(flags, baseFactory2) {
     node.modifiers = asNodeArray(modifiers);
     node.parameters = createNodeArray(parameters);
     node.body = body;
-    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | 1024 /* ContainsES2015 */;
+    if (!node.body) {
+      node.transformFlags = 1 /* ContainsTypeScript */;
+    } else {
+      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | 1024 /* ContainsES2015 */;
+    }
     node.typeParameters = void 0;
     node.type = void 0;
     node.typeArguments = void 0;
@@ -25405,7 +25419,7 @@ var asyncGeneratorHelper = {
         var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
             if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
             var g = generator.apply(thisArg, _arguments || []), i, q = [];
-            return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+            return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
             function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
             function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
             function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
@@ -25587,8 +25601,8 @@ var generatorHelper = {
   priority: 6,
   text: `
             var __generator = (this && this.__generator) || function (thisArg, body) {
-                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-                return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+                return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
                 function verb(n) { return function (v) { return step([n, v]); }; }
                 function step(op) {
                     if (f) throw new TypeError("Generator is already executing.");
@@ -44339,9 +44353,32 @@ function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignatu
 }
 
 // src/compiler/moduleSpecifiers.ts
-function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }, host, compilerOptions, importingSourceFile, oldImportSpecifier) {
+var stringToRegex = memoizeOne((pattern) => {
+  try {
+    let slash = pattern.indexOf("/");
+    if (slash !== 0) {
+      return new RegExp(pattern);
+    }
+    const lastSlash = pattern.lastIndexOf("/");
+    if (slash === lastSlash) {
+      return new RegExp(pattern);
+    }
+    while ((slash = pattern.indexOf("/", slash + 1)) !== lastSlash) {
+      if (pattern[slash - 1] !== "\\") {
+        return new RegExp(pattern);
+      }
+    }
+    const flags = pattern.substring(lastSlash + 1).replace(/[^iu]/g, "");
+    pattern = pattern.substring(1, lastSlash);
+    return new RegExp(pattern, flags);
+  } catch {
+    return void 0;
+  }
+});
+function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding, autoImportSpecifierExcludeRegexes }, host, compilerOptions, importingSourceFile, oldImportSpecifier) {
   const filePreferredEnding = getPreferredEnding();
   return {
+    excludeRegexes: autoImportSpecifierExcludeRegexes,
     relativePreference: oldImportSpecifier !== void 0 ? isExternalModuleNameRelative(oldImportSpecifier) ? 0 /* Relative */ : 1 /* NonRelative */ : importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : 2 /* Shortest */,
     getAllowedEndingsInPreferredOrder: (syntaxImpliedNodeFormat) => {
       const impliedNodeFormat = getDefaultResolutionModeForFile(importingSourceFile, host, compilerOptions);
@@ -44410,7 +44447,13 @@ function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSo
 function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
   let computedWithoutCache = false;
   const ambient = tryGetModuleNameFromAmbientModule(moduleSymbol, checker);
-  if (ambient) return { kind: "ambient", moduleSpecifiers: [ambient], computedWithoutCache };
+  if (ambient) {
+    return {
+      kind: "ambient",
+      moduleSpecifiers: !(forAutoImport && isExcludedByRegex(ambient, userPreferences.autoImportSpecifierExcludeRegexes)) ? [ambient] : emptyArray,
+      computedWithoutCache
+    };
+  }
   let [kind, specifiers, moduleSourceFile, modulePaths, cache] = tryGetModuleSpecifiersFromCacheWorker(
     moduleSymbol,
     importingSourceFile,
@@ -44470,9 +44513,11 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
       void 0,
       options.overrideImportMode
     ) : void 0;
-    nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
-    if (specifier && modulePath.isRedirect) {
-      return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true };
+    if (specifier && !(forAutoImport && isExcludedByRegex(specifier, preferences.excludeRegexes))) {
+      nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
+      if (modulePath.isRedirect) {
+        return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true };
+      }
     }
     if (!specifier) {
       const local = getLocalModuleSpecifier(
@@ -44485,7 +44530,7 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
         /*pathsOnly*/
         modulePath.isRedirect
       );
-      if (!local) {
+      if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) {
         continue;
       }
       if (modulePath.isRedirect) {
@@ -44501,7 +44546,13 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
       }
     }
   }
-  return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? { kind: "paths", moduleSpecifiers: pathsSpecifiers, computedWithoutCache: true } : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? { kind: "redirect", moduleSpecifiers: redirectPathsSpecifiers, computedWithoutCache: true } : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true } : { kind: "relative", moduleSpecifiers: Debug.checkDefined(relativeSpecifiers), computedWithoutCache: true };
+  return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? { kind: "paths", moduleSpecifiers: pathsSpecifiers, computedWithoutCache: true } : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? { kind: "redirect", moduleSpecifiers: redirectPathsSpecifiers, computedWithoutCache: true } : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true } : { kind: "relative", moduleSpecifiers: relativeSpecifiers ?? emptyArray, computedWithoutCache: true };
+}
+function isExcludedByRegex(moduleSpecifier, excludeRegexes) {
+  return some(excludeRegexes, (pattern) => {
+    var _a;
+    return !!((_a = stringToRegex(pattern)) == null ? void 0 : _a.test(moduleSpecifier));
+  });
 }
 function getInfo(importingSourceFileName, host) {
   importingSourceFileName = getNormalizedAbsolutePath(importingSourceFileName, host.getCurrentDirectory());
@@ -44514,7 +44565,7 @@ function getInfo(importingSourceFileName, host) {
     canonicalSourceDirectory: getCanonicalFileName(sourceDirectory)
   };
 }
-function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { getAllowedEndingsInPreferredOrder: getAllowedEndingsInPrefererredOrder, relativePreference }, pathsOnly) {
+function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { getAllowedEndingsInPreferredOrder: getAllowedEndingsInPrefererredOrder, relativePreference, excludeRegexes }, pathsOnly) {
   const { baseUrl, paths, rootDirs } = compilerOptions;
   if (pathsOnly && !paths) {
     return void 0;
@@ -44530,7 +44581,14 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   if (!relativeToBaseUrl) {
     return pathsOnly ? void 0 : relativePath;
   }
-  const fromPackageJsonImports = pathsOnly ? void 0 : tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, compilerOptions, host, importMode);
+  const fromPackageJsonImports = pathsOnly ? void 0 : tryGetModuleNameFromPackageJsonImports(
+    moduleFileName,
+    sourceDirectory,
+    compilerOptions,
+    host,
+    importMode,
+    prefersTsExtension(allowedEndings)
+  );
   const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) : void 0;
   if (pathsOnly) {
     return fromPaths;
@@ -44539,6 +44597,14 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   if (!maybeNonRelative) {
     return relativePath;
   }
+  const relativeIsExcluded = isExcludedByRegex(relativePath, excludeRegexes);
+  const nonRelativeIsExcluded = isExcludedByRegex(maybeNonRelative, excludeRegexes);
+  if (!relativeIsExcluded && nonRelativeIsExcluded) {
+    return relativePath;
+  }
+  if (relativeIsExcluded && !nonRelativeIsExcluded) {
+    return maybeNonRelative;
+  }
   if (relativePreference === 1 /* NonRelative */ && !pathIsRelative(maybeNonRelative)) {
     return maybeNonRelative;
   }
@@ -44763,7 +44829,7 @@ function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, hos
     return ending !== 0 /* Minimal */ || value === processEnding(relativeToBaseUrl, [ending], compilerOptions, host);
   }
 }
-function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, exports2, conditions, mode, isImports) {
+function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, exports2, conditions, mode, isImports, preferTsExtension) {
   if (typeof exports2 === "string") {
     const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
     const getCommonSourceDirectory2 = () => host.getCommonSourceDirectory();
@@ -44775,6 +44841,7 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
       void 0
     );
     const extensionSwappedTarget = hasTSFileExtension(targetFilePath) ? removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : void 0;
+    const canTryTsExtension = preferTsExtension && hasImplementationTSFileExtension(targetFilePath);
     switch (mode) {
       case 0 /* Exact */:
         if (extensionSwappedTarget && comparePaths(extensionSwappedTarget, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || comparePaths(targetFilePath, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || outputFile && comparePaths(outputFile, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || declarationFile && comparePaths(declarationFile, pathOrPattern, ignoreCase) === 0 /* EqualTo */) {
@@ -44782,6 +44849,19 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
         }
         break;
       case 1 /* Directory */:
+        if (canTryTsExtension && containsPath(targetFilePath, pathOrPattern, ignoreCase)) {
+          const fragment = getRelativePathFromDirectory(
+            pathOrPattern,
+            targetFilePath,
+            /*ignoreCase*/
+            false
+          );
+          return { moduleFileToTry: getNormalizedAbsolutePath(
+            combinePaths(combinePaths(packageName, exports2), fragment),
+            /*currentDirectory*/
+            void 0
+          ) };
+        }
         if (extensionSwappedTarget && containsPath(pathOrPattern, extensionSwappedTarget, ignoreCase)) {
           const fragment = getRelativePathFromDirectory(
             pathOrPattern,
@@ -44795,7 +44875,7 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
             void 0
           ) };
         }
-        if (containsPath(pathOrPattern, targetFilePath, ignoreCase)) {
+        if (!canTryTsExtension && containsPath(pathOrPattern, targetFilePath, ignoreCase)) {
           const fragment = getRelativePathFromDirectory(
             pathOrPattern,
             targetFilePath,
@@ -44818,12 +44898,12 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
           return { moduleFileToTry: combinePaths(packageName, fragment) };
         }
         if (declarationFile && containsPath(pathOrPattern, declarationFile, ignoreCase)) {
-          const fragment = getRelativePathFromDirectory(
+          const fragment = changeFullExtension(getRelativePathFromDirectory(
             pathOrPattern,
             declarationFile,
             /*ignoreCase*/
             false
-          );
+          ), getJSExtensionForFile(declarationFile, options));
           return { moduleFileToTry: combinePaths(packageName, fragment) };
         }
         break;
@@ -44831,11 +44911,15 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
         const starPos = pathOrPattern.indexOf("*");
         const leadingSlice = pathOrPattern.slice(0, starPos);
         const trailingSlice = pathOrPattern.slice(starPos + 1);
+        if (canTryTsExtension && startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
+          const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
+          return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
+        }
         if (extensionSwappedTarget && startsWith(extensionSwappedTarget, leadingSlice, ignoreCase) && endsWith(extensionSwappedTarget, trailingSlice, ignoreCase)) {
           const starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
           return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
         }
-        if (startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
+        if (!canTryTsExtension && startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
           const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
           return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
         }
@@ -44845,17 +44929,19 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
         }
         if (declarationFile && startsWith(declarationFile, leadingSlice, ignoreCase) && endsWith(declarationFile, trailingSlice, ignoreCase)) {
           const starReplacement = declarationFile.slice(leadingSlice.length, declarationFile.length - trailingSlice.length);
-          return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
+          const substituted = replaceFirstStar(packageName, starReplacement);
+          const jsExtension = tryGetJSExtensionForFile(declarationFile, options);
+          return jsExtension ? { moduleFileToTry: changeFullExtension(substituted, jsExtension) } : void 0;
         }
         break;
     }
   } else if (Array.isArray(exports2)) {
-    return forEach(exports2, (e) => tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, e, conditions, mode, isImports));
+    return forEach(exports2, (e) => tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, e, conditions, mode, isImports, preferTsExtension));
   } else if (typeof exports2 === "object" && exports2 !== null) {
     for (const key of getOwnKeys(exports2)) {
       if (key === "default" || conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(conditions, key)) {
         const subTarget = exports2[key];
-        const result = tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode, isImports);
+        const result = tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode, isImports, preferTsExtension);
         if (result) {
           return result;
         }
@@ -44883,6 +44969,8 @@ function tryGetModuleNameFromExports(options, host, targetFilePath, packageDirec
         conditions,
         mode,
         /*isImports*/
+        false,
+        /*preferTsExtension*/
         false
       );
     });
@@ -44897,10 +44985,12 @@ function tryGetModuleNameFromExports(options, host, targetFilePath, packageDirec
     conditions,
     0 /* Exact */,
     /*isImports*/
+    false,
+    /*preferTsExtension*/
     false
   );
 }
-function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, options, host, importMode) {
+function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, options, host, importMode, preferTsExtension) {
   var _a, _b, _c;
   if (!host.readFile || !getResolvePackageJsonImports(options)) {
     return void 0;
@@ -44933,7 +45023,8 @@ function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory,
       conditions,
       mode,
       /*isImports*/
-      true
+      true,
+      preferTsExtension
     );
   })) == null ? void 0 : _c.moduleFileToTry;
 }
@@ -45015,7 +45106,15 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
         const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
         const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2);
         const conditions = getConditions(options, importMode);
-        const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0;
+        const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(
+          options,
+          host,
+          path,
+          packageRootPath,
+          packageName2,
+          packageJsonContent.exports,
+          conditions
+        ) : void 0;
         if (fromExports) {
           return { ...fromExports, verbatimFromExports: true };
         }
@@ -45163,6 +45262,10 @@ function isPathRelativeToParent(path) {
 function getDefaultResolutionModeForFile(file, host, compilerOptions) {
   return isFullSourceFile(file) ? host.getDefaultResolutionModeForFile(file) : getDefaultResolutionModeForFileWorker(file, compilerOptions);
 }
+function prefersTsExtension(allowedEndings) {
+  const tsPriority = allowedEndings.indexOf(3 /* TsExtension */);
+  return tsPriority > -1 && tsPriority < allowedEndings.indexOf(2 /* JsExtension */);
+}
 
 // src/compiler/checker.ts
 var ambientModuleSymbolRegex = /^".+"$/;
@@ -49357,6 +49460,7 @@ function createTypeChecker(host) {
   }
   function symbolToString(symbol, enclosingDeclaration, meaning, flags = 4 /* AllowAnyNodeKind */, writer) {
     let nodeFlags = 70221824 /* IgnoreErrors */;
+    let internalNodeFlags = 0 /* None */;
     if (flags & 2 /* UseOnlyExternalAliasing */) {
       nodeFlags |= 128 /* UseOnlyExternalAliasing */;
     }
@@ -49367,15 +49471,15 @@ function createTypeChecker(host) {
       nodeFlags |= 16384 /* UseAliasDefinedOutsideCurrentScope */;
     }
     if (flags & 32 /* DoNotIncludeSymbolChain */) {
-      nodeFlags |= 134217728 /* DoNotIncludeSymbolChain */;
+      internalNodeFlags |= 4 /* DoNotIncludeSymbolChain */;
     }
     if (flags & 16 /* WriteComputedProps */) {
-      nodeFlags |= 1073741824 /* WriteComputedProps */;
+      internalNodeFlags |= 1 /* WriteComputedProps */;
     }
     const builder = flags & 4 /* AllowAnyNodeKind */ ? nodeBuilder.symbolToNode : nodeBuilder.symbolToEntityName;
     return writer ? symbolToStringWorker(writer).getText() : usingSingleLineStringWriter(symbolToStringWorker);
     function symbolToStringWorker(writer2) {
-      const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
+      const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags, internalNodeFlags);
       const printer = (enclosingDeclaration == null ? void 0 : enclosingDeclaration.kind) === 307 /* SourceFile */ ? createPrinterWithRemoveCommentsNeverAsciiEscape() : createPrinterWithRemoveComments();
       const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
       printer.writeNode(
@@ -49412,7 +49516,13 @@ function createTypeChecker(host) {
   }
   function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
     const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
-    const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0));
+    const typeNode = nodeBuilder.typeToTypeNode(
+      type,
+      enclosingDeclaration,
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
+      /*internalFlags*/
+      void 0
+    );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
     const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
@@ -49461,31 +49571,31 @@ function createTypeChecker(host) {
   }
   function createNodeBuilder() {
     return {
-      typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
         /*typeNode*/
         void 0
       )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToName(
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
         symbol,
         context,
         meaning,
         /*expectsIdentifier*/
         false
       )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -49507,13 +49617,13 @@ function createTypeChecker(host) {
       return setTextRange(setOriginalNode(range, location), location);
     }
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
-      const oldFlags = context.flags;
-      if (expr && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+      const restoreFlags = saveRestoreFlags(context);
+      if (expr && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
         syntacticNodeBuilder.serializeTypeOfExpression(expr, context, addUndefined);
       }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
+      context.internalFlags |= 2 /* NoSyntacticPrinter */;
       const result = expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined);
-      context.flags = oldFlags;
+      restoreFlags();
       return result;
     }
     function expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined) {
@@ -49566,7 +49676,7 @@ function createTypeChecker(host) {
       return void 0;
     }
     function symbolToNode(symbol, context, meaning) {
-      if (context.flags & 1073741824 /* WriteComputedProps */) {
+      if (context.internalFlags & 1 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
           const name = getNameOfDeclaration(symbol.valueDeclaration);
           if (name && isComputedPropertyName(name)) return name;
@@ -49579,12 +49689,13 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, tracker, cb) {
-      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
+    function withContext(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
         enclosingFile: enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration),
         flags: flags || 0 /* None */,
+        internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
         encounteredError: false,
         reportedDiagnostic: false,
@@ -49614,14 +49725,23 @@ function createTypeChecker(host) {
       }
       return context.encounteredError ? void 0 : resultingNode;
     }
+    function saveRestoreFlags(context) {
+      const flags = context.flags;
+      const internalFlags = context.internalFlags;
+      return restore;
+      function restore() {
+        context.flags = flags;
+        context.internalFlags = internalFlags;
+      }
+    }
     function checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
     function typeToTypeNodeHelper(type, context) {
-      const savedFlags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       const typeNode = typeToTypeNodeWorker(type, context);
-      context.flags = savedFlags;
+      restoreFlags();
       return typeNode;
     }
     function typeToTypeNodeWorker(type, context) {
@@ -50075,7 +50195,7 @@ function createTypeChecker(host) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
         const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
-        const key = `${getTypeId(type2)}|${context.flags}`;
+        const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
         }
@@ -50181,10 +50301,10 @@ function createTypeChecker(host) {
           }
           return typeToTypeNodeHelper(getIntersectionType(types), context);
         }
-        const savedFlags = context.flags;
+        const restoreFlags = saveRestoreFlags(context);
         context.flags |= 4194304 /* InObjectTypeLiteral */;
         const members = createTypeNodesFromResolvedType(resolved);
-        context.flags = savedFlags;
+        restoreFlags();
         const typeLiteralNode = factory.createTypeLiteralNode(members);
         context.approximateLength += 2;
         setEmitFlags(typeLiteralNode, context.flags & 1024 /* MultilineObjectLiterals */ ? 0 : 1 /* SingleLine */);
@@ -50247,10 +50367,10 @@ function createTypeChecker(host) {
               } while (i < length2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
               if (!rangeEquals(outerTypeParameters, typeArguments, start, i)) {
                 const typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context);
-                const flags2 = context.flags;
+                const restoreFlags2 = saveRestoreFlags(context);
                 context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
                 const ref = symbolToTypeNode(parent, context, 788968 /* Type */, typeArgumentSlice);
-                context.flags = flags2;
+                restoreFlags2();
                 resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
               }
             }
@@ -50288,10 +50408,10 @@ function createTypeChecker(host) {
             }
             typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
           }
-          const flags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
           const finalRef = symbolToTypeNode(type2.symbol, context, 788968 /* Type */, typeArgumentNodes);
-          context.flags = flags;
+          restoreFlags();
           return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
         }
       }
@@ -50603,7 +50723,7 @@ function createTypeChecker(host) {
           }
         }
         if (seenNames) {
-          const saveContextFlags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 64 /* UseFullyQualifiedType */;
           seenNames.forEach((types2) => {
             if (!arrayIsHomogeneous(types2, ([a], [b]) => typesAreSameReference(a, b))) {
@@ -50612,7 +50732,7 @@ function createTypeChecker(host) {
               }
             }
           });
-          context.flags = saveContextFlags;
+          restoreFlags();
         }
         return result;
       }
@@ -50664,19 +50784,19 @@ function createTypeChecker(host) {
       } else {
         typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
       }
-      const flags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       context.flags &= ~256 /* SuppressAnyReturnType */;
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      context.flags = flags;
+      restoreFlags();
       const returnTypeNode = serializeReturnTypeForSignature(context, signature);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags2 = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
+        const flags = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -50896,13 +51016,13 @@ function createTypeChecker(host) {
       }
     }
     function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
-      const savedContextFlags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       context.flags &= ~512 /* WriteTypeParametersInQualifiedName */;
       const modifiers = factory.createModifiersFromModifierFlags(getTypeParameterModifiers(type));
       const name = typeParameterToName(type, context);
       const defaultParameter = getDefaultFromTypeParameter(type);
       const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
-      context.flags = savedContextFlags;
+      restoreFlags();
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
@@ -51006,7 +51126,7 @@ function createTypeChecker(host) {
     function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
       let chain;
       const isTypeParameter = symbol.flags & 262144 /* TypeParameter */;
-      if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.flags & 134217728 /* DoNotIncludeSymbolChain */)) {
+      if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.internalFlags & 4 /* DoNotIncludeSymbolChain */)) {
         chain = Debug.checkDefined(getSymbolChain(
           symbol,
           meaning,
@@ -51532,19 +51652,19 @@ function createTypeChecker(host) {
       var _a, _b;
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
-      const oldFlags = context.flags;
-      if (declaration && hasInferredType(declaration) && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+      const restoreFlags = saveRestoreFlags(context);
+      if (declaration && hasInferredType(declaration) && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
         syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context);
       }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
-      if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
+      context.internalFlags |= 2 /* NoSyntacticPrinter */;
+      if (enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */)) {
         const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol);
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           const addUndefined = addUndefinedForParameter || !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declWithExistingAnnotation) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type));
           const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
-            context.flags = oldFlags;
+            restoreFlags();
             return result2;
           }
         }
@@ -51555,7 +51675,7 @@ function createTypeChecker(host) {
       const decl = declaration ?? symbol.valueDeclaration ?? ((_b = symbol.declarations) == null ? void 0 : _b[0]);
       const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
       const result = expressionOrTypeToTypeNode(context, expr, type, addUndefinedForParameter);
-      context.flags = oldFlags;
+      restoreFlags();
       return result;
     }
     function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) {
@@ -51569,26 +51689,26 @@ function createTypeChecker(host) {
     }
     function serializeReturnTypeForSignature(context, signature) {
       const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      const flags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       if (suppressAny) context.flags &= ~256 /* SuppressAnyReturnType */;
       let returnTypeNode;
       const returnType = getReturnTypeOfSignature(signature);
       if (returnType && !(suppressAny && isTypeAny(returnType))) {
-        if (signature.declaration && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+        if (signature.declaration && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
           syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, context);
         }
-        context.flags |= -2147483648 /* NoSyntacticPrinter */;
+        context.internalFlags |= 2 /* NoSyntacticPrinter */;
         returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
       } else if (!suppressAny) {
         returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
       }
-      context.flags = flags;
+      restoreFlags();
       return returnTypeNode;
     }
     function serializeReturnTypeForSignatureWorker(context, signature) {
       const typePredicate = getTypePredicateOfSignature(signature);
       const type = getReturnTypeOfSignature(signature);
-      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+      if (context.enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
         const annotation = getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
         if (annotation) {
           const result = tryReuseExistingTypeNode(context, annotation, type, context.enclosingDeclaration);
@@ -52090,7 +52210,7 @@ function createTypeChecker(host) {
           if (!hasDynamicName(node)) {
             return visitEachChild2(node, visitExistingNodeTreeSymbols);
           }
-          if (!(context.flags & 1 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
+          if (!(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
             return void 0;
           }
         }
@@ -52742,7 +52862,7 @@ function createTypeChecker(host) {
         const typeParamDecls = map(typeParams, (p) => typeParameterToDeclaration(p, context));
         const jsdocAliasDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isJSDocTypeAlias);
         const commentText = getTextOfJSDocComment(jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : void 0);
-        const oldFlags = context.flags;
+        const restoreFlags = saveRestoreFlags(context);
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
@@ -52766,7 +52886,7 @@ function createTypeChecker(host) {
           ),
           modifierFlags
         );
-        context.flags = oldFlags;
+        restoreFlags();
         context.enclosingDeclaration = oldEnclosingDecl;
       }
       function serializeInterface(symbol, symbolName2, modifierFlags) {
@@ -53775,10 +53895,10 @@ function createTypeChecker(host) {
       }
       function getNameCandidateWorker(symbol, localName) {
         if (localName === "default" /* Default */ || localName === "__class" /* Class */ || localName === "__function" /* Function */) {
-          const flags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 16777216 /* InInitialEntityName */;
           const nameCandidate = getNameOfSymbolAsWritten(symbol, context);
-          context.flags = flags;
+          restoreFlags();
           localName = nameCandidate.length > 0 && isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? stripQuotes(nameCandidate) : nameCandidate;
         }
         if (localName === "default" /* Default */) {
@@ -55361,7 +55481,8 @@ function createTypeChecker(host) {
       if (!node) {
         return void 0;
       }
-      switch (node.kind) {
+      const kind = node.kind;
+      switch (kind) {
         case 263 /* ClassDeclaration */:
         case 231 /* ClassExpression */:
         case 264 /* InterfaceDeclaration */:
@@ -55383,13 +55504,19 @@ function createTypeChecker(host) {
         case 200 /* MappedType */:
         case 194 /* ConditionalType */: {
           const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
-          if (node.kind === 200 /* MappedType */) {
+          if ((kind === 218 /* FunctionExpression */ || kind === 219 /* ArrowFunction */ || isObjectLiteralMethod(node)) && isContextSensitive(node)) {
+            const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfDeclaration(node)), 0 /* Call */));
+            if (signature && signature.typeParameters) {
+              return [...outerTypeParameters || emptyArray, ...signature.typeParameters];
+            }
+          }
+          if (kind === 200 /* MappedType */) {
             return append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter)));
-          } else if (node.kind === 194 /* ConditionalType */) {
+          } else if (kind === 194 /* ConditionalType */) {
             return concatenate(outerTypeParameters, getInferTypeParameters(node));
           }
           const outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(node));
-          const thisType = includeThisTypes && (node.kind === 263 /* ClassDeclaration */ || node.kind === 231 /* ClassExpression */ || node.kind === 264 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfDeclaration(node)).thisType;
+          const thisType = includeThisTypes && (kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 264 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfDeclaration(node)).thisType;
           return thisType ? append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
         }
         case 341 /* JSDocParameterTag */:
@@ -58201,8 +58328,11 @@ function createTypeChecker(host) {
       true
     );
   }
+  function getTypeParametersForMapper(signature) {
+    return sameMap(signature.typeParameters, (tp) => tp.mapper ? instantiateType(tp, tp.mapper) : tp);
+  }
   function createSignatureTypeMapper(signature, typeArguments) {
-    return createTypeMapper(sameMap(signature.typeParameters, (tp) => tp.mapper ? instantiateType(tp, tp.mapper) : tp), typeArguments);
+    return createTypeMapper(getTypeParametersForMapper(signature), typeArguments);
   }
   function getErasedSignature(signature) {
     return signature.typeParameters ? signature.erasedSignatureCache || (signature.erasedSignatureCache = createErasedSignature(signature)) : signature;
@@ -71216,7 +71346,7 @@ function createTypeChecker(host) {
       type,
       (t) => {
         var _a;
-        if (isGenericMappedType(t) && !t.declaration.nameType) {
+        if (isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */) {
           const constraint = getConstraintTypeFromMappedType(t);
           const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
           const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
@@ -73902,7 +74032,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
-    const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
+    const context = createInferenceContext(getTypeParametersForMapper(signature), signature, 0 /* None */, compareTypes);
     const restType = getEffectiveRestType(contextualSignature);
     const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
@@ -85939,14 +86069,14 @@ function createTypeChecker(host) {
       return 11 /* ObjectType */;
     }
   }
-  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker) {
+  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
     if (!declaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
     const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
@@ -85989,14 +86119,14 @@ function createTypeChecker(host) {
     }
     return candidateExpr;
   }
-  function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
+  function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
-  function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
+  function createTypeOfExpression(exprIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
     if (!expr) {
       return factory.createToken(133 /* AnyKeyword */);
@@ -86009,6 +86139,7 @@ function createTypeChecker(host) {
       void 0,
       enclosingDeclaration,
       flags | 1024 /* MultilineObjectLiterals */,
+      internalFlags,
       tracker
     );
   }
@@ -86114,6 +86245,8 @@ function createTypeChecker(host) {
       enclosing,
       /*flags*/
       void 0,
+      /*internalFlags*/
+      void 0,
       tracker
     ) : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
     if (enumResult) return enumResult;
@@ -86242,15 +86375,15 @@ function createTypeChecker(host) {
         const parseDecl = getParseTreeNode(decl);
         return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
       },
-      getDeclarationStatementsForSourceFile: (node, flags, tracker) => {
+      getDeclarationStatementsForSourceFile: (node, flags, internalFlags, tracker) => {
         const n = getParseTreeNode(node);
         Debug.assert(n && n.kind === 307 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
         const sym = getSymbolOfDeclaration(node);
         if (!sym) {
-          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
+          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, internalFlags, tracker);
         }
         resolveExternalModuleSymbol(sym);
-        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
+        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, internalFlags, tracker);
       },
       isImportRequiredByAugmentation,
       isDefinitelyReferenceToGlobalSymbolObject
@@ -91222,7 +91355,6 @@ function transformTypeScript(context) {
   let currentNamespaceContainerName;
   let currentLexicalScope;
   let currentScopeFirstDeclarationsOfName;
-  let currentClassHasParameterProperties;
   let enabledSubstitutions;
   let applicableSubstitutions;
   return transformSourceFileOrBundle;
@@ -91250,14 +91382,12 @@ function transformTypeScript(context) {
   function saveStateAndInvoke(node, f) {
     const savedCurrentScope = currentLexicalScope;
     const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
-    const savedCurrentClassHasParameterProperties = currentClassHasParameterProperties;
     onBeforeVisitNode(node);
     const visited = f(node);
     if (currentLexicalScope !== savedCurrentScope) {
       currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
     }
     currentLexicalScope = savedCurrentScope;
-    currentClassHasParameterProperties = savedCurrentClassHasParameterProperties;
     return visited;
   }
   function onBeforeVisitNode(node) {
@@ -91890,7 +92020,7 @@ function transformTypeScript(context) {
   }
   function visitPropertyNameOfClassElement(member) {
     const name = member.name;
-    if (isComputedPropertyName(name) && (!hasStaticModifier(member) && currentClassHasParameterProperties || hasDecorators(member) && legacyDecorators)) {
+    if (legacyDecorators && isComputedPropertyName(name) && hasDecorators(member)) {
       const expression = visitNode(name.expression, visitor, isExpression);
       Debug.assert(expression);
       const innerExpression = skipPartiallyEmittedExpressions(expression);
@@ -111353,7 +111483,8 @@ function getDeclarationDiagnostics(host, resolver, file) {
     false
   ).diagnostics : void 0;
 }
-var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitInternalNodeBuilderFlags = 8 /* AllowUnresolvedNames */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
   let getSymbolAccessibilityDiagnostic = throwDiagnostic;
@@ -111509,7 +111640,7 @@ function transformDeclarations(context) {
       diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
       errorNode: s.errorNode || sourceFile
     };
-    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker);
+    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
     getSymbolAccessibilityDiagnostic = oldDiag;
     return result;
   }
@@ -111779,7 +111910,7 @@ function transformDeclarations(context) {
       case 172 /* PropertyDeclaration */:
       case 208 /* BindingElement */:
       case 260 /* VariableDeclaration */:
-        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
         break;
       case 262 /* FunctionDeclaration */:
       case 180 /* ConstructSignature */:
@@ -111787,7 +111918,7 @@ function transformDeclarations(context) {
       case 174 /* MethodDeclaration */:
       case 177 /* GetAccessor */:
       case 179 /* CallSignature */:
-        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
         break;
       default:
         Debug.assertNever(node);
@@ -112388,7 +112519,7 @@ function transformDeclarations(context) {
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker),
+            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
             /*initializer*/
             void 0
           );
@@ -112514,7 +112645,7 @@ function transformDeclarations(context) {
               return void 0;
             }
             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
-            const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags | -2147483648 /* NoSyntacticPrinter */, symbolTracker);
+            const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags | 2 /* NoSyntacticPrinter */, symbolTracker);
             getSymbolAccessibilityDiagnostic = oldDiag;
             const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
             const name = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
@@ -112717,7 +112848,7 @@ function transformDeclarations(context) {
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, symbolTracker),
+            resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
             /*initializer*/
             void 0
           );