typescript 5.6.0-dev.20240808 → 5.6.0-dev.20240809

package/lib/typescript.js

@@ -96,6 +96,7 @@ __export(typescript_exports, {
   InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
+  InternalNodeBuilderFlags: () => InternalNodeBuilderFlags,
   InternalSymbolName: () => InternalSymbolName,
   IntersectionFlags: () => IntersectionFlags,
   InvalidatedProjectKind: () => InvalidatedProjectKind,
@@ -2260,7 +2261,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240808`;
+var version = `${versionMajorMinor}.0-dev.20240809`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6168,17 +6169,21 @@ var NodeBuilderFlags = /* @__PURE__ */ ((NodeBuilderFlags2) => {
   NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyTuple"] = 524288] = "AllowEmptyTuple";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyIndexInfoType"] = 2097152] = "AllowEmptyIndexInfoType";
-  NodeBuilderFlags2[NodeBuilderFlags2["WriteComputedProps"] = 1073741824] = "WriteComputedProps";
-  NodeBuilderFlags2[NodeBuilderFlags2["NoSyntacticPrinter"] = -2147483648] = "NoSyntacticPrinter";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths";
-  NodeBuilderFlags2[NodeBuilderFlags2["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain";
-  NodeBuilderFlags2[NodeBuilderFlags2["AllowUnresolvedNames"] = 1] = "AllowUnresolvedNames";
   NodeBuilderFlags2[NodeBuilderFlags2["IgnoreErrors"] = 70221824] = "IgnoreErrors";
   NodeBuilderFlags2[NodeBuilderFlags2["InObjectTypeLiteral"] = 4194304] = "InObjectTypeLiteral";
   NodeBuilderFlags2[NodeBuilderFlags2["InTypeAlias"] = 8388608] = "InTypeAlias";
   NodeBuilderFlags2[NodeBuilderFlags2["InInitialEntityName"] = 16777216] = "InInitialEntityName";
   return NodeBuilderFlags2;
 })(NodeBuilderFlags || {});
+var InternalNodeBuilderFlags = /* @__PURE__ */ ((InternalNodeBuilderFlags2) => {
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["None"] = 0] = "None";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["WriteComputedProps"] = 1] = "WriteComputedProps";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["NoSyntacticPrinter"] = 2] = "NoSyntacticPrinter";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["DoNotIncludeSymbolChain"] = 4] = "DoNotIncludeSymbolChain";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["AllowUnresolvedNames"] = 8] = "AllowUnresolvedNames";
+  return InternalNodeBuilderFlags2;
+})(InternalNodeBuilderFlags || {});
 var TypeFormatFlags = /* @__PURE__ */ ((TypeFormatFlags2) => {
   TypeFormatFlags2[TypeFormatFlags2["None"] = 0] = "None";
   TypeFormatFlags2[TypeFormatFlags2["NoTruncation"] = 1] = "NoTruncation";
@@ -25386,7 +25391,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;
@@ -29555,7 +29564,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); } }
@@ -29737,8 +29746,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.");
@@ -53977,6 +53986,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 */;
     }
@@ -53987,15 +53997,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(
@@ -54032,7 +54042,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);
@@ -54081,31 +54097,31 @@ function createTypeChecker(host) {
   }
   function createNodeBuilder() {
     return {
-      typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
         /*typeNode*/
         void 0
       )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToName(
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
         symbol,
         context,
         meaning,
         /*expectsIdentifier*/
         false
       )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -54127,13 +54143,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) {
@@ -54186,7 +54202,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;
@@ -54199,12 +54215,13 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext2(enclosingDeclaration, flags, tracker, cb) {
-      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
+    function withContext2(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,
@@ -54234,14 +54251,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) {
@@ -54695,7 +54721,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());
         }
@@ -54801,10 +54827,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 */);
@@ -54867,10 +54893,10 @@ function createTypeChecker(host) {
               } while (i < length2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent2);
               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(parent2, context, 788968 /* Type */, typeArgumentSlice);
-                context.flags = flags2;
+                restoreFlags2();
                 resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
               }
             }
@@ -54908,10 +54934,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);
         }
       }
@@ -55223,7 +55249,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))) {
@@ -55232,7 +55258,7 @@ function createTypeChecker(host) {
               }
             }
           });
-          context.flags = saveContextFlags;
+          restoreFlags();
         }
         return result;
       }
@@ -55284,19 +55310,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,
@@ -55516,13 +55542,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) {
@@ -55626,7 +55652,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,
@@ -56152,19 +56178,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;
           }
         }
@@ -56175,7 +56201,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) {
@@ -56189,26 +56215,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);
@@ -56710,7 +56736,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;
           }
         }
@@ -57362,7 +57388,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;
@@ -57386,7 +57412,7 @@ function createTypeChecker(host) {
           ),
           modifierFlags
         );
-        context.flags = oldFlags;
+        restoreFlags();
         context.enclosingDeclaration = oldEnclosingDecl;
       }
       function serializeInterface(symbol, symbolName2, modifierFlags) {
@@ -58395,10 +58421,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 */) {
@@ -59981,7 +60007,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 */:
@@ -60003,13 +60030,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 */:
@@ -62821,8 +62854,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;
@@ -75836,7 +75872,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));
@@ -78522,7 +78558,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;
@@ -90559,14 +90595,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);
@@ -90609,14 +90645,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 */);
@@ -90629,6 +90665,7 @@ function createTypeChecker(host) {
       void 0,
       enclosingDeclaration,
       flags | 1024 /* MultilineObjectLiterals */,
+      internalFlags,
       tracker
     );
   }
@@ -90734,6 +90771,8 @@ function createTypeChecker(host) {
       enclosing,
       /*flags*/
       void 0,
+      /*internalFlags*/
+      void 0,
       tracker
     ) : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
     if (enumResult) return enumResult;
@@ -90862,15 +90901,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
@@ -96024,7 +96063,6 @@ function transformTypeScript(context) {
   let currentNamespaceContainerName;
   let currentLexicalScope;
   let currentScopeFirstDeclarationsOfName;
-  let currentClassHasParameterProperties;
   let enabledSubstitutions;
   let applicableSubstitutions;
   return transformSourceFileOrBundle;
@@ -96052,14 +96090,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) {
@@ -96692,7 +96728,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);
@@ -116155,7 +116191,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;
@@ -116311,7 +116348,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;
   }
@@ -116581,7 +116618,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 */:
@@ -116589,7 +116626,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);
@@ -117190,7 +117227,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
           );
@@ -117316,7 +117353,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);
@@ -117519,7 +117556,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
           );
@@ -138309,7 +138346,7 @@ function getTypeNodeIfAccessible(type, enclosingScope, program, host) {
   const checker = program.getTypeChecker();
   let typeIsAccessible = true;
   const notAccessible = () => typeIsAccessible = false;
-  const res = checker.typeToTypeNode(type, enclosingScope, 1 /* NoTruncation */, {
+  const res = checker.typeToTypeNode(type, enclosingScope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */, {
     trackSymbol: (symbol, declaration, meaning) => {
       typeIsAccessible = typeIsAccessible && checker.isSymbolAccessible(
         symbol,
@@ -144166,7 +144203,7 @@ function updateImportsInOtherFiles(changes, program, host, oldFile, movedSymbols
         deleteUnusedImports(sourceFile, importNode, changes, shouldMove);
         const pathToTargetFileWithExtension = resolvePath(getDirectoryPath(getNormalizedAbsolutePath(oldFile.fileName, program.getCurrentDirectory())), targetFileName);
         if (getStringComparer(!program.useCaseSensitiveFileNames())(pathToTargetFileWithExtension, sourceFile.fileName) === 0 /* EqualTo */) return;
-        const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
+        const newModuleSpecifier = ts_moduleSpecifiers_exports.getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
         const newImportDeclaration = filterImport(importNode, makeStringLiteral(newModuleSpecifier, quotePreference), shouldMove);
         if (newImportDeclaration) changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);
         const ns = getNamespaceLikeImport(importNode);
@@ -147233,7 +147270,7 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
     if (!isJS) {
       let type = checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node);
       type = checker.getBaseTypeOfLiteralType(type);
-      typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, 1 /* NoTruncation */);
+      typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
     }
     const paramDecl = factory.createParameterDeclaration(
       /*modifiers*/
@@ -147262,7 +147299,7 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
   )) : void 0;
   if (isExpression(node) && !isJS) {
     const contextualType = checker.getContextualType(node);
-    returnType = checker.typeToTypeNode(contextualType, scope, 1 /* NoTruncation */);
+    returnType = checker.typeToTypeNode(contextualType, scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   }
   const { body, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & 1 /* HasReturn */));
   suppressLeadingAndTrailingTrivia(body);
@@ -147302,7 +147339,8 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
           checker.typeToTypeNode(
             checker.getTypeAtLocation(range.thisNode),
             scope,
-            1 /* NoTruncation */
+            1 /* NoTruncation */,
+            8 /* AllowUnresolvedNames */
           ),
           /*initializer*/
           void 0
@@ -147399,7 +147437,8 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
         const variableType = checker.typeToTypeNode(
           checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(variableDeclaration)),
           scope,
-          1 /* NoTruncation */
+          1 /* NoTruncation */,
+          8 /* AllowUnresolvedNames */
         );
         typeElements.push(factory.createPropertySignature(
           /*modifiers*/
@@ -147530,7 +147569,7 @@ function extractConstantInScope(node, scope, { substitutions }, rangeFacts, cont
   const file = scope.getSourceFile();
   const localNameText = getIdentifierForNode(node, scope, checker, file);
   const isJS = isInJSFile(scope);
-  let variableType = isJS || !checker.isContextSensitive(node) ? void 0 : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NoTruncation */);
+  let variableType = isJS || !checker.isContextSensitive(node) ? void 0 : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   let initializer = transformConstantInitializer(skipParentheses(node), substitutions);
   ({ variableType, initializer } = transformFunctionInitializerAndType(variableType, initializer));
   suppressLeadingAndTrailingTrivia(initializer);
@@ -147655,13 +147694,13 @@ function extractConstantInScope(node, scope, { substitutions }, rangeFacts, cont
       } else {
         const paramType = checker.getTypeAtLocation(p);
         if (paramType === checker.getAnyType()) hasAny = true;
-        parameters.push(factory.updateParameterDeclaration(p, p.modifiers, p.dotDotDotToken, p.name, p.questionToken, p.type || checker.typeToTypeNode(paramType, scope, 1 /* NoTruncation */), p.initializer));
+        parameters.push(factory.updateParameterDeclaration(p, p.modifiers, p.dotDotDotToken, p.name, p.questionToken, p.type || checker.typeToTypeNode(paramType, scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */), p.initializer));
       }
     }
     if (hasAny) return { variableType: variableType2, initializer: initializer2 };
     variableType2 = void 0;
     if (isArrowFunction(initializer2)) {
-      initializer2 = factory.updateArrowFunction(initializer2, canHaveModifiers(node) ? getModifiers(node) : void 0, initializer2.typeParameters, parameters, initializer2.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NoTruncation */), initializer2.equalsGreaterThanToken, initializer2.body);
+      initializer2 = factory.updateArrowFunction(initializer2, canHaveModifiers(node) ? getModifiers(node) : void 0, initializer2.typeParameters, parameters, initializer2.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */), initializer2.equalsGreaterThanToken, initializer2.body);
     } else {
       if (functionSignature && !!functionSignature.thisParameter) {
         const firstParameter = firstOrUndefined(parameters);
@@ -147678,7 +147717,7 @@ function extractConstantInScope(node, scope, { substitutions }, rangeFacts, cont
               "this",
               /*questionToken*/
               void 0,
-              checker.typeToTypeNode(thisType, scope, 1 /* NoTruncation */)
+              checker.typeToTypeNode(thisType, scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */)
             )
           );
         }
@@ -148299,7 +148338,7 @@ function getInfo4(context) {
     if (signature) {
       const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
       if (typePredicate && typePredicate.type) {
-        const typePredicateTypeNode = typeChecker.typePredicateToTypePredicateNode(typePredicate, declaration, 1 /* NoTruncation */);
+        const typePredicateTypeNode = typeChecker.typePredicateToTypePredicateNode(typePredicate, declaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
         if (typePredicateTypeNode) {
           return { declaration, returnTypeNode: typePredicateTypeNode };
         }
@@ -148311,7 +148350,7 @@ function getInfo4(context) {
   if (!returnType) {
     return { error: getLocaleSpecificMessage(Diagnostics.Could_not_determine_function_return_type) };
   }
-  const returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NoTruncation */);
+  const returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   if (returnTypeNode) {
     return { declaration, returnTypeNode };
   }
@@ -154823,6 +154862,8 @@ function addMissingDeclarations(context, implementedTypeNode, sourceFile, classD
         classDeclaration,
         /*flags*/
         void 0,
+        /*internalFlags*/
+        void 0,
         getNoopSymbolTrackerWithResolver(context)
       ));
     }
@@ -156454,6 +156495,8 @@ function addMissingConstraint(changes, program, preferences, host, sourceFile, i
       scriptTarget,
       /*flags*/
       void 0,
+      /*internalFlags*/
+      void 0,
       tracker
     );
     if (typeNode) {
@@ -157561,14 +157604,15 @@ function getTypeNode2(checker, node, token) {
     const binaryExpression = token.parent.parent;
     const otherExpression = token.parent === binaryExpression.left ? binaryExpression.right : binaryExpression.left;
     const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(otherExpression)));
-    typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NoTruncation */);
+    typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   } else {
     const contextualType = checker.getContextualType(token.parent);
     typeNode = contextualType ? checker.typeToTypeNode(
       contextualType,
       /*enclosingDeclaration*/
       void 0,
-      1 /* NoTruncation */
+      1 /* NoTruncation */,
+      8 /* AllowUnresolvedNames */
     ) : void 0;
   }
   return typeNode || factory.createKeywordTypeNode(133 /* AnyKeyword */);
@@ -157890,7 +157934,9 @@ function createPropertyNameFromSymbol(symbol, target, quotePreference, checker)
       111551 /* Value */,
       /*enclosingDeclaration*/
       void 0,
-      1073741824 /* WriteComputedProps */
+      /*flags*/
+      void 0,
+      1 /* WriteComputedProps */
     );
     if (prop && isComputedPropertyName(prop)) return prop;
   }
@@ -158063,7 +158109,7 @@ function tryGetName2(node) {
   }
 }
 function typeToTypeNode(checker, type, enclosingDeclaration) {
-  return checker.typeToTypeNode(checker.getWidenedType(type), enclosingDeclaration, 1 /* NoTruncation */) ?? factory.createKeywordTypeNode(159 /* UnknownKeyword */);
+  return checker.typeToTypeNode(checker.getWidenedType(type), enclosingDeclaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */) ?? factory.createKeywordTypeNode(159 /* UnknownKeyword */);
 }
 function doChange19(changes, program, preferences, host, declarations, newParameters) {
   const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
@@ -159366,7 +159412,8 @@ var canHaveTypeAnnotation = /* @__PURE__ */ new Set([
   206 /* ObjectBindingPattern */,
   207 /* ArrayBindingPattern */
 ]);
-var declarationEmitNodeBuilderFlags2 = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */ | 1073741824 /* WriteComputedProps */;
+var declarationEmitNodeBuilderFlags2 = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitInternalNodeBuilderFlags2 = 1 /* WriteComputedProps */;
 registerCodeFix({
   errorCodes: errorCodes47,
   fixIds: [fixId36],
@@ -160152,7 +160199,7 @@ function withContext(context, typePrintMode, cb) {
   }
   function typeToTypeNode2(type, enclosingDeclaration, flags = 0 /* None */) {
     let isTruncated = false;
-    const result2 = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, {
+    const result2 = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, declarationEmitInternalNodeBuilderFlags2, {
       moduleResolverHost: program,
       trackSymbol() {
         return true;
@@ -160165,7 +160212,7 @@ function withContext(context, typePrintMode, cb) {
   }
   function typePredicateToTypeNode(typePredicate, enclosingDeclaration, flags = 0 /* None */) {
     let isTruncated = false;
-    const result2 = typePredicateToAutoImportableTypeNode(typeChecker, importAdder, typePredicate, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, {
+    const result2 = typePredicateToAutoImportableTypeNode(typeChecker, importAdder, typePredicate, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, declarationEmitInternalNodeBuilderFlags2, {
       moduleResolverHost: program,
       trackSymbol() {
         return true;
@@ -161492,7 +161539,7 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
     case 172 /* PropertyDeclaration */:
       let flags = 1 /* NoTruncation */;
       flags |= quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0;
-      let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
+      let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
       if (importAdder) {
         const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
         if (importableReference) {
@@ -161517,6 +161564,8 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
         enclosingDeclaration,
         /*flags*/
         void 0,
+        /*internalFlags*/
+        void 0,
         getNoopSymbolTrackerWithResolver(context)
       );
       const allAccessors = getAllAccessorDeclarations(declarations, declaration);
@@ -161646,7 +161695,7 @@ function createSignatureDeclarationFromSignature(kind, context, quotePreference,
   const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
   const isJs = isInJSFile(enclosingDeclaration);
   const flags = 1 /* NoTruncation */ | 256 /* SuppressAnyReturnType */ | 524288 /* AllowEmptyTuple */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
-  const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
+  const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
   if (!signatureDeclaration) {
     return void 0;
   }
@@ -161747,6 +161796,7 @@ function createSignatureDeclarationFromCallExpression(kind, context, importAdder
     contextNode,
     scriptTarget,
     1 /* NoTruncation */,
+    8 /* AllowUnresolvedNames */,
     tracker
   );
   const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : void 0;
@@ -161765,6 +161815,8 @@ function createSignatureDeclarationFromCallExpression(kind, context, importAdder
     contextNode,
     /*flags*/
     void 0,
+    /*internalFlags*/
+    void 0,
     tracker
   );
   switch (kind) {
@@ -161834,8 +161886,8 @@ function createTypeParametersForArguments(checker, argumentTypeParameters, typeA
 function createTypeParameterName(index) {
   return 84 /* T */ + index <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + index) : `T${index}`;
 }
-function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
-  let typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
+function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, internalFlags, tracker) {
+  let typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker);
   if (typeNode && isImportTypeNode(typeNode)) {
     const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
     if (importableReference) {
@@ -161845,8 +161897,8 @@ function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, s
   }
   return getSynthesizedDeepClone(typeNode);
 }
-function typePredicateToAutoImportableTypeNode(checker, importAdder, typePredicate, contextNode, scriptTarget, flags, tracker) {
-  let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, tracker);
+function typePredicateToAutoImportableTypeNode(checker, importAdder, typePredicate, contextNode, scriptTarget, flags, internalFlags, tracker) {
+  let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, internalFlags, tracker);
   if ((typePredicateNode == null ? void 0 : typePredicateNode.type) && isImportTypeNode(typePredicateNode.type)) {
     const importableReference = tryGetAutoImportableReferenceFromTypeNode(typePredicateNode.type, scriptTarget);
     if (importableReference) {
@@ -161862,7 +161914,7 @@ function typeContainsTypeParameter(type) {
   }
   return type.flags & 262144 /* TypeParameter */;
 }
-function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, tracker) {
+function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, internalFlags, tracker) {
   const argumentTypeNodes = [];
   const argumentTypeParameters = /* @__PURE__ */ new Map();
   for (let i = 0; i < instanceTypes.length; i += 1) {
@@ -161874,13 +161926,13 @@ function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes,
       continue;
     }
     const widenedInstanceType = checker.getBaseTypeOfLiteralType(instanceType);
-    const argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, tracker);
+    const argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, internalFlags, tracker);
     if (!argumentTypeNode) {
       continue;
     }
     argumentTypeNodes.push(argumentTypeNode);
     const argumentTypeParameter = getFirstTypeParameterName(instanceType);
-    const instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint) ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, tracker) : void 0;
+    const instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint) ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, internalFlags, tracker) : void 0;
     if (argumentTypeParameter) {
       argumentTypeParameters.set(argumentTypeParameter, { argumentType: instanceType, constraint: instanceTypeConstraint });
     }
@@ -161980,7 +162032,7 @@ function createMethodImplementingSignatures(checker, context, enclosingDeclarati
 function getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration) {
   if (length(signatures)) {
     const type = checker.getUnionType(map(signatures, checker.getReturnTypeOfSignature));
-    return checker.typeToTypeNode(type, enclosingDeclaration, 1 /* NoTruncation */, getNoopSymbolTrackerWithResolver(context));
+    return checker.typeToTypeNode(type, enclosingDeclaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
   }
 }
 function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference, body) {
@@ -164555,7 +164607,14 @@ function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, pro
       if (signatures.length !== 1) {
         return void 0;
       }
-      const typeNode = checker.typeToTypeNode(effectiveType, enclosingDeclaration, builderFlags, ts_codefix_exports.getNoopSymbolTrackerWithResolver({ program, host }));
+      const typeNode = checker.typeToTypeNode(
+        effectiveType,
+        enclosingDeclaration,
+        builderFlags,
+        /*internalFlags*/
+        void 0,
+        ts_codefix_exports.getNoopSymbolTrackerWithResolver({ program, host })
+      );
       if (!typeNode || !isFunctionTypeNode(typeNode)) {
         return void 0;
       }
@@ -167659,7 +167718,7 @@ function getFilenameWithExtensionOption(name, program, extensionOptions, isExpor
   if (extensionOptions.referenceKind === 0 /* Filename */) {
     return { name, extension: tryGetExtensionFromPath2(name) };
   }
-  let allowedEndings = getModuleSpecifierPreferences(
+  let allowedEndings = ts_moduleSpecifiers_exports.getModuleSpecifierPreferences(
     { importModuleSpecifierEnding: extensionOptions.endingPreference },
     program,
     program.getCompilerOptions(),
@@ -179235,6 +179294,7 @@ __export(ts_exports2, {
   InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
+  InternalNodeBuilderFlags: () => InternalNodeBuilderFlags,
   InternalSymbolName: () => InternalSymbolName,
   IntersectionFlags: () => IntersectionFlags,
   InvalidatedProjectKind: () => InvalidatedProjectKind,
@@ -193620,6 +193680,7 @@ if (typeof console !== "undefined") {
   InlayHintKind,
   InlayHints,
   InternalEmitFlags,
+  InternalNodeBuilderFlags,
   InternalSymbolName,
   IntersectionFlags,
   InvalidatedProjectKind,