@typescript-deploys/pr-build 5.5.0-pr-57649-11 → 5.5.0-pr-58124-21

package/lib/typescript.js

@@ -414,6 +414,7 @@ __export(typescript_exports, {
   createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
   createFlowNode: () => createFlowNode,
   createForOfBindingStatement: () => createForOfBindingStatement,
+  createFutureSourceFile: () => createFutureSourceFile,
   createGetCanonicalFileName: () => createGetCanonicalFileName,
   createGetSourceFile: () => createGetSourceFile,
   createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
@@ -1185,6 +1186,7 @@ __export(typescript_exports, {
   isAnyDirectorySeparator: () => isAnyDirectorySeparator,
   isAnyImportOrBareOrAccessedRequire: () => isAnyImportOrBareOrAccessedRequire,
   isAnyImportOrReExport: () => isAnyImportOrReExport,
+  isAnyImportOrRequireStatement: () => isAnyImportOrRequireStatement,
   isAnyImportSyntax: () => isAnyImportSyntax,
   isAnySupportedFileExtension: () => isAnySupportedFileExtension,
   isApplicableVersionedTypesKey: () => isApplicableVersionedTypesKey,
@@ -1375,6 +1377,7 @@ __export(typescript_exports, {
   isForInitializer: () => isForInitializer,
   isForOfStatement: () => isForOfStatement,
   isForStatement: () => isForStatement,
+  isFullSourceFile: () => isFullSourceFile,
   isFunctionBlock: () => isFunctionBlock,
   isFunctionBody: () => isFunctionBody,
   isFunctionDeclaration: () => isFunctionDeclaration,
@@ -2335,7 +2338,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240408`;
+var version = `${versionMajorMinor}.0-insiders.20240410`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -16246,6 +16249,9 @@ function isAnyImportSyntax(node) {
 function isAnyImportOrBareOrAccessedRequire(node) {
   return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node);
 }
+function isAnyImportOrRequireStatement(node) {
+  return isAnyImportSyntax(node) || isRequireVariableStatement(node);
+}
 function isLateVisibilityPaintedStatement(node) {
   switch (node.kind) {
     case 272 /* ImportDeclaration */:
@@ -17282,6 +17288,9 @@ function getExternalModuleRequireArgument(node) {
 function isInternalModuleImportEqualsDeclaration(node) {
   return node.kind === 271 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 283 /* ExternalModuleReference */;
 }
+function isFullSourceFile(sourceFile) {
+  return (sourceFile == null ? void 0 : sourceFile.kind) === 307 /* SourceFile */;
+}
 function isSourceFileJS(file) {
   return isInJSFile(file);
 }
@@ -21249,12 +21258,12 @@ function getModuleSpecifierEndingPreference(preference, resolutionMode, compiler
     return 1 /* Index */;
   }
   if (!shouldAllowImportingTsExtension(compilerOptions)) {
-    return usesExtensionsOnImports(sourceFile) ? 2 /* JsExtension */ : 0 /* Minimal */;
+    return sourceFile && usesExtensionsOnImports(sourceFile) ? 2 /* JsExtension */ : 0 /* Minimal */;
   }
   return inferPreference();
   function inferPreference() {
     let usesJsExtensions = false;
-    const specifiers = sourceFile.imports.length ? sourceFile.imports : isSourceFileJS(sourceFile) ? getRequiresAtTopOfFile(sourceFile).map((r) => r.arguments[0]) : emptyArray;
+    const specifiers = (sourceFile == null ? void 0 : sourceFile.imports.length) ? sourceFile.imports : sourceFile && isSourceFileJS(sourceFile) ? getRequiresAtTopOfFile(sourceFile).map((r) => r.arguments[0]) : emptyArray;
     for (const specifier of specifiers) {
       if (pathIsRelative(specifier.text)) {
         if (moduleResolutionIsNodeNext && resolutionMode === 1 /* CommonJS */ && getModeForUsageLocation(sourceFile, specifier, compilerOptions) === 99 /* ESNext */) {
@@ -47310,6 +47319,7 @@ __export(ts_moduleSpecifiers_exports, {
   RelativePreference: () => RelativePreference,
   countPathComponents: () => countPathComponents,
   forEachFileNameOfModule: () => forEachFileNameOfModule,
+  getLocalModuleSpecifierBetweenFileNames: () => getLocalModuleSpecifierBetweenFileNames,
   getModuleSpecifier: () => getModuleSpecifier,
   getModuleSpecifierPreferences: () => getModuleSpecifierPreferences,
   getModuleSpecifiers: () => getModuleSpecifiers,
@@ -47370,7 +47380,7 @@ function getModuleSpecifierPreferences({ importModuleSpecifierPreference, import
       importModuleSpecifierEnding,
       resolutionMode ?? importingSourceFile.impliedNodeFormat,
       compilerOptions,
-      importingSourceFile
+      isFullSourceFile(importingSourceFile) ? importingSourceFile : void 0
     );
   }
 }
@@ -47475,10 +47485,22 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
   cache == null ? void 0 : cache.set(importingSourceFile.path, moduleSourceFile.path, userPreferences, options, modulePaths, result);
   return { moduleSpecifiers: result, computedWithoutCache };
 }
+function getLocalModuleSpecifierBetweenFileNames(importingFile, targetFileName, compilerOptions, host, options = {}) {
+  const info = getInfo(importingFile.fileName, host);
+  const importMode = options.overrideImportMode ?? importingFile.impliedNodeFormat;
+  return getLocalModuleSpecifier(
+    targetFileName,
+    info,
+    compilerOptions,
+    host,
+    importMode,
+    getModuleSpecifierPreferences({}, compilerOptions, importingFile)
+  );
+}
 function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
   const info = getInfo(importingSourceFile.fileName, host);
   const preferences = getModuleSpecifierPreferences(userPreferences, compilerOptions, importingSourceFile);
-  const existingSpecifier = forEach(modulePaths, (modulePath) => forEach(
+  const existingSpecifier = isFullSourceFile(importingSourceFile) && forEach(modulePaths, (modulePath) => forEach(
     host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
     (reason) => {
       if (reason.kind !== 3 /* Import */ || reason.file !== importingSourceFile.path)
@@ -49980,7 +50002,6 @@ function createTypeChecker(host) {
     let result;
     let lastLocation;
     let lastSelfReferenceLocation;
-    let seenAsUsedOutsideOfSelf = false;
     let propertyWithInvalidInitializer;
     let associatedDeclarationForContainingInitializerOrBindingName;
     let withinDeferredContext = false;
@@ -50192,9 +50213,6 @@ function createTypeChecker(host) {
               location = location.parent.parent.parent;
             }
             break;
-          case 175 /* ClassStaticBlockDeclaration */:
-            seenAsUsedOutsideOfSelf = true;
-            break;
         }
         if (isSelfReferenceLocation(location)) {
           lastSelfReferenceLocation = location;
@@ -50202,7 +50220,7 @@ function createTypeChecker(host) {
         lastLocation = location;
         location = isJSDocTemplateTag(location) ? getEffectiveContainerForJSDocTemplateTag(location) || location.parent : isJSDocParameterTag(location) || isJSDocReturnTag(location) ? getHostSignatureFromJSDoc(location) || location.parent : location.parent;
       }
-    if (isUse && result && (seenAsUsedOutsideOfSelf || !lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
+    if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
       result.isReferenced |= meaning;
     }
     if (!result) {
@@ -52895,7 +52913,7 @@ function createTypeChecker(host) {
       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: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, 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(
         indexInfo,
@@ -52918,6 +52936,18 @@ function createTypeChecker(host) {
       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))
     };
+    function setTextRange2(context, range, location) {
+      if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
+        range = factory.cloneNode(range);
+      }
+      if (!location) {
+        return range;
+      }
+      if (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(location))) {
+        return setOriginalNode(range, location);
+      }
+      return setTextRange(setOriginalNode(range, location), location);
+    }
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
       if (expr) {
         const typeNode = isAssertionExpression(expr) ? expr.type : isJSDocTypeAssertion(expr) ? getJSDocTypeAssertionType(expr) : void 0;
@@ -52982,6 +53012,7 @@ function createTypeChecker(host) {
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
+        enclosingFile: enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration),
         flags: flags || 0 /* None */,
         tracker: void 0,
         encounteredError: false,
@@ -53514,7 +53545,7 @@ function createTypeChecker(host) {
           if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
             return node;
           }
-          return setTextRange(factory.cloneNode(visitEachChild(
+          return setTextRange2(context, factory.cloneNode(visitEachChild(
             node,
             deepCloneOrReuseNode,
             /*context*/
@@ -53856,7 +53887,13 @@ function createTypeChecker(host) {
           context.reverseMappedStack || (context.reverseMappedStack = []);
           context.reverseMappedStack.push(propertySymbol);
         }
-        propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(133 /* AnyKeyword */);
+        propertyTypeNode = propertyType ? serializeTypeForDeclaration(
+          context,
+          /*declaration*/
+          void 0,
+          propertyType,
+          propertySymbol
+        ) : factory.createKeywordTypeNode(133 /* AnyKeyword */);
         if (propertyIsReverseMapped) {
           context.reverseMappedStack.pop();
         }
@@ -54245,8 +54282,7 @@ function createTypeChecker(host) {
     function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
       const parameterType = getTypeOfSymbol(parameterSymbol);
-      const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, addUndefined);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterDeclaration, parameterType, parameterSymbol);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -54838,10 +54874,12 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined) {
+    function serializeTypeForDeclaration(context, declaration, type, symbol) {
       var _a;
+      const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
+      const enclosingDeclaration = context.enclosingDeclaration;
       if (!isErrorType(type) && enclosingDeclaration) {
-        const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
+        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
@@ -54854,7 +54892,7 @@ function createTypeChecker(host) {
       if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
         context.flags |= 1048576 /* AllowUniqueESSymbolType */;
       }
-      const decl = symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
+      const decl = declaration ?? symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
       const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
       const result = expressionOrTypeToTypeNode(context, expr, type, addUndefined);
       context.flags = oldFlags;
@@ -54968,7 +55006,7 @@ function createTypeChecker(host) {
           const type = getDeclaredTypeOfSymbol(sym);
           const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node2);
           name.symbol = sym;
-          return setTextRange(setEmitFlags(setOriginalNode(name, node2), 16777216 /* NoAsciiEscaping */), node2);
+          return setTextRange2(context, setEmitFlags(name, 16777216 /* NoAsciiEscaping */), node2);
         }
         const updated = visitEachChild(
           node2,
@@ -54977,7 +55015,7 @@ function createTypeChecker(host) {
           void 0
         );
         if (updated !== node2) {
-          setTextRange(updated, node2);
+          setTextRange2(context, updated, node2);
         }
         return updated;
       }
@@ -54991,12 +55029,12 @@ function createTypeChecker(host) {
       if (hadError) {
         return void 0;
       }
-      return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
+      return transformed;
       function visitExistingNodeTreeSymbols(node) {
         const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
         const result = visitExistingNodeTreeSymbolsWorker(node);
         onExitNewScope == null ? void 0 : onExitNewScope();
-        return result;
+        return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
       }
       function onEnterNewScope(node) {
         const oldContex = context;
@@ -55132,7 +55170,7 @@ function createTypeChecker(host) {
             void 0
           );
           if (visited === node) {
-            visited = setTextRange(factory.cloneNode(node), node);
+            visited = setTextRange2(context, factory.cloneNode(node), node);
           }
           visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
           if (isParameter(node)) {
@@ -55155,11 +55193,16 @@ function createTypeChecker(host) {
             /*context*/
             void 0
           );
-          const clone2 = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
+          const clone2 = setTextRange2(context, visited === node ? factory.cloneNode(node) : visited, node);
           const flags = getEmitFlags(clone2);
           setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
           return clone2;
         }
+        if (isStringLiteral(node) && !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */) && !node.singleQuote) {
+          const clone2 = factory.cloneNode(node);
+          clone2.singleQuote = true;
+          return clone2;
+        }
         if (isConditionalTypeNode(node)) {
           const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
           const disposeScope = onEnterNewScope(node);
@@ -55538,7 +55581,8 @@ function createTypeChecker(host) {
                 );
                 context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551 /* Value */);
               } else {
-                const statement = setTextRange(
+                const statement = setTextRange2(
+                  context,
                   factory.createVariableStatement(
                     /*modifiers*/
                     void 0,
@@ -55547,7 +55591,13 @@ function createTypeChecker(host) {
                         name,
                         /*exclamationToken*/
                         void 0,
-                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration)
+                        serializeTypeForDeclaration(
+                          context,
+                          /*declaration*/
+                          void 0,
+                          type,
+                          symbol
+                        )
                       )
                     ], flags)
                   ),
@@ -55820,7 +55870,7 @@ function createTypeChecker(host) {
         const signatures = getSignaturesOfType(type, 0 /* Call */);
         for (const sig of signatures) {
           const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName) });
-          addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
+          addResult(setTextRange2(context, decl, getSignatureTextRangeLocation(sig)), modifierFlags);
         }
         if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
           const props = filter(getPropertiesOfType(type), isNamespaceMember);
@@ -55998,7 +56048,8 @@ function createTypeChecker(host) {
         const indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
         context.enclosingDeclaration = oldEnclosing;
         addResult(
-          setTextRange(
+          setTextRange2(
+            context,
             factory.createClassDeclaration(
               /*modifiers*/
               void 0,
@@ -56358,7 +56409,13 @@ function createTypeChecker(host) {
                   varName,
                   /*exclamationToken*/
                   void 0,
-                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration)
+                  serializeTypeForDeclaration(
+                    context,
+                    /*declaration*/
+                    void 0,
+                    typeToSerialize,
+                    symbol
+                  )
                 )
               ], flags)
             );
@@ -56430,7 +56487,8 @@ function createTypeChecker(host) {
               });
               Debug.assert(!!setter);
               const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : void 0;
-              result.push(setTextRange(
+              result.push(setTextRange2(
+                context,
                 factory.createSetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
                   name,
@@ -56442,7 +56500,13 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration)
+                    isPrivate ? void 0 : serializeTypeForDeclaration(
+                      context,
+                      /*declaration*/
+                      void 0,
+                      getTypeOfSymbol(p),
+                      p
+                    )
                   )],
                   /*body*/
                   void 0
@@ -56452,12 +56516,19 @@ function createTypeChecker(host) {
             }
             if (p.flags & 32768 /* GetAccessor */) {
               const isPrivate2 = modifierFlags & 2 /* Private */;
-              result.push(setTextRange(
+              result.push(setTextRange2(
+                context,
                 factory.createGetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
+                  isPrivate2 ? void 0 : serializeTypeForDeclaration(
+                    context,
+                    /*declaration*/
+                    void 0,
+                    getTypeOfSymbol(p),
+                    p
+                  ),
                   /*body*/
                   void 0
                 ),
@@ -56466,12 +56537,19 @@ function createTypeChecker(host) {
             }
             return result;
           } else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
-            return setTextRange(
+            return setTextRange2(
+              context,
               createProperty2(
                 factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration),
+                isPrivate ? void 0 : serializeTypeForDeclaration(
+                  context,
+                  /*declaration*/
+                  void 0,
+                  getWriteTypeOfSymbol(p),
+                  p
+                ),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
@@ -56484,7 +56562,8 @@ function createTypeChecker(host) {
             const type = getTypeOfSymbol(p);
             const signatures = getSignaturesOfType(type, 0 /* Call */);
             if (flag & 2 /* Private */) {
-              return setTextRange(
+              return setTextRange2(
+                context,
                 createProperty2(
                   factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                   name,
@@ -56510,7 +56589,7 @@ function createTypeChecker(host) {
                 }
               );
               const location = sig.declaration && isPrototypePropertyAssignment(sig.declaration.parent) ? sig.declaration.parent : sig.declaration;
-              results2.push(setTextRange(decl, location));
+              results2.push(setTextRange2(context, decl, location));
             }
             return results2;
           }
@@ -56566,7 +56645,8 @@ function createTypeChecker(host) {
             }
           }
           if (privateProtected) {
-            return [setTextRange(
+            return [setTextRange2(
+              context,
               factory.createConstructorDeclaration(
                 factory.createModifiersFromModifierFlags(privateProtected),
                 /*parameters*/
@@ -56581,7 +56661,7 @@ function createTypeChecker(host) {
         const results2 = [];
         for (const sig of signatures) {
           const decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
-          results2.push(setTextRange(decl, sig.declaration));
+          results2.push(setTextRange2(context, decl, sig.declaration));
         }
         return results2;
       }
@@ -60264,12 +60344,10 @@ function createTypeChecker(host) {
     const target = type.target ?? type;
     const typeVariable = getHomomorphicTypeVariable(target);
     if (typeVariable && !target.declaration.nameType) {
-      const constraint = getConstraintTypeFromMappedType(type);
-      if (constraint.flags & 4194304 /* Index */) {
-        const baseConstraint = getBaseConstraintOfType(constraint.type);
-        if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
-          return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
-        }
+      const modifiersType = getModifiersTypeFromMappedType(type);
+      const baseConstraint = isGenericMappedType(modifiersType) ? getApparentTypeOfMappedType(modifiersType) : getBaseConstraintOfType(modifiersType);
+      if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
+        return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
       }
     }
     return type;
@@ -60430,13 +60508,13 @@ function createTypeChecker(host) {
   }
   function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
     var _a, _b, _c;
-    let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
+    let property = skipObjectFunctionPropertyAugment ? (_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name) : (_b = type.propertyCache) == null ? void 0 : _b.get(name);
     if (!property) {
       property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
       if (property) {
         const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
         properties.set(name, property);
-        if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+        if (skipObjectFunctionPropertyAugment && !(getCheckFlags(property) & 48 /* Partial */) && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
           const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
           properties2.set(name, property);
         }
@@ -65699,7 +65777,7 @@ function createTypeChecker(host) {
         const sourceTypePredicate = getTypePredicateOfSignature(source);
         if (sourceTypePredicate) {
           result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors2, errorReporter, compareTypes);
-        } else if (isIdentifierTypePredicate(targetTypePredicate)) {
+        } else if (isIdentifierTypePredicate(targetTypePredicate) || isThisTypePredicate(targetTypePredicate)) {
           if (reportErrors2) {
             errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
           }
@@ -71419,7 +71497,7 @@ function createTypeChecker(host) {
       case 80 /* Identifier */:
         if (!isThisInTypeQuery(node)) {
           const symbol = getResolvedSymbol(node);
-          return isConstantVariable(symbol) || isParameterOrMutableLocalVariable(symbol) && !isSymbolAssigned(symbol);
+          return isConstantVariable(symbol) || isParameterOrMutableLocalVariable(symbol) && !isSymbolAssigned(symbol) || !!symbol.valueDeclaration && isFunctionExpression(symbol.valueDeclaration);
         }
         break;
       case 211 /* PropertyAccessExpression */:
@@ -79431,7 +79509,7 @@ function createTypeChecker(host) {
             true
           );
         }
-        if (expr.kind === 213 /* CallExpression */ && expr.expression.kind === 80 /* Identifier */ && checkExpressionCached(expr.expression).symbol === func.symbol) {
+        if (expr.kind === 213 /* CallExpression */ && expr.expression.kind === 80 /* Identifier */ && checkExpressionCached(expr.expression).symbol === getMergedSymbol(func.symbol) && (!isFunctionExpressionOrArrowFunction(func.symbol.valueDeclaration) || isConstantReference(expr.expression))) {
           hasReturnOfTypeNever = true;
           return;
         }
@@ -88083,9 +88161,10 @@ function createTypeChecker(host) {
     return false;
   }
   function declaredParameterTypeContainsUndefined(parameter) {
-    if (!parameter.type)
+    const typeNode = getNonlocalEffectiveTypeAnnotationNode(parameter);
+    if (!typeNode)
       return false;
-    const type = getTypeFromTypeNode(parameter.type);
+    const type = getTypeFromTypeNode(typeNode);
     return containsUndefinedType(type);
   }
   function requiresAddingImplicitUndefined(parameter) {
@@ -88095,7 +88174,7 @@ function createTypeChecker(host) {
     return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isOptionalUninitializedParameterProperty(parameter) {
-    return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
+    return strictNullChecks && isOptionalParameter(parameter) && (isJSDocParameterTag(parameter) || !parameter.initializer) && hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isExpandoFunctionDeclaration(node) {
     const declaration = getParseTreeNode(node, isFunctionDeclaration);
@@ -88245,14 +88324,14 @@ function createTypeChecker(host) {
       return 11 /* ObjectType */;
     }
   }
-  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) {
+  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, 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(type, symbol, addUndefined, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
@@ -114092,7 +114171,7 @@ function transformDeclarations(context) {
       case 172 /* PropertyDeclaration */:
       case 208 /* BindingElement */:
       case 260 /* VariableDeclaration */:
-        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
         break;
       case 262 /* FunctionDeclaration */:
       case 180 /* ConstructSignature */:
@@ -134631,7 +134710,7 @@ function getQuotePreference(sourceFile, preferences) {
   if (preferences.quotePreference && preferences.quotePreference !== "auto") {
     return preferences.quotePreference === "single" ? 0 /* Single */ : 1 /* Double */;
   } else {
-    const firstModuleSpecifier = sourceFile.imports && find(sourceFile.imports, (n) => isStringLiteral(n) && !nodeIsSynthesized(n.parent));
+    const firstModuleSpecifier = isFullSourceFile(sourceFile) && sourceFile.imports && find(sourceFile.imports, (n) => isStringLiteral(n) && !nodeIsSynthesized(n.parent));
     return firstModuleSpecifier ? quotePreferenceFromString(firstModuleSpecifier, sourceFile) : 1 /* Double */;
   }
 }
@@ -134689,14 +134768,24 @@ function findModifier(node, kind) {
   return canHaveModifiers(node) ? find(node.modifiers, (m) => m.kind === kind) : void 0;
 }
 function insertImports(changes, sourceFile, imports, blankLineBetween, preferences) {
+  var _a;
   const decl = isArray(imports) ? imports[0] : imports;
   const importKindPredicate = decl.kind === 243 /* VariableStatement */ ? isRequireVariableStatement : isAnyImportSyntax;
   const existingImportStatements = filter(sourceFile.statements, importKindPredicate);
   const { comparer, isSorted } = ts_OrganizeImports_exports.getOrganizeImportsStringComparerWithDetection(existingImportStatements, preferences);
   const sortedNewImports = isArray(imports) ? stableSort(imports, (a, b) => ts_OrganizeImports_exports.compareImportsOrRequireStatements(a, b, comparer)) : [imports];
-  if (!existingImportStatements.length) {
-    changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween);
-  } else if (existingImportStatements && isSorted) {
+  if (!(existingImportStatements == null ? void 0 : existingImportStatements.length)) {
+    if (isFullSourceFile(sourceFile)) {
+      changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween);
+    } else {
+      for (const newImport of sortedNewImports) {
+        changes.insertStatementsInNewFile(sourceFile.fileName, [newImport], (_a = getOriginalNode(newImport)) == null ? void 0 : _a.getSourceFile());
+      }
+    }
+    return;
+  }
+  Debug.assert(isFullSourceFile(sourceFile));
+  if (existingImportStatements && isSorted) {
     for (const newImport of sortedNewImports) {
       const insertionIndex = ts_OrganizeImports_exports.getImportDeclarationInsertionIndex(existingImportStatements, newImport, comparer);
       if (insertionIndex === 0) {
@@ -135622,7 +135711,7 @@ function createPackageJsonImportFilter(fromFile, preferences, host) {
     return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier);
   }
   function isAllowedCoreNodeModulesImport(moduleSpecifier) {
-    if (isSourceFileJS(fromFile) && ts_JsTyping_exports.nodeCoreModules.has(moduleSpecifier)) {
+    if (isFullSourceFile(fromFile) && isSourceFileJS(fromFile) && ts_JsTyping_exports.nodeCoreModules.has(moduleSpecifier)) {
       if (usesNodeCoreModules === void 0) {
         usesNodeCoreModules = consumesNodeCoreModules(fromFile);
       }
@@ -135929,6 +136018,25 @@ function isBlockLike(node) {
       return false;
   }
 }
+function createFutureSourceFile(fileName, syntaxModuleIndicator, program, moduleResolutionHost) {
+  var _a;
+  const result = getImpliedNodeFormatForFileWorker(fileName, (_a = program.getPackageJsonInfoCache) == null ? void 0 : _a.call(program), moduleResolutionHost, program.getCompilerOptions());
+  let impliedNodeFormat, packageJsonScope;
+  if (typeof result === "object") {
+    impliedNodeFormat = result.impliedNodeFormat;
+    packageJsonScope = result.packageJsonScope;
+  }
+  return {
+    path: toPath(fileName, program.getCurrentDirectory(), program.getCanonicalFileName),
+    fileName,
+    externalModuleIndicator: syntaxModuleIndicator === 99 /* ESNext */ ? true : void 0,
+    commonJsModuleIndicator: syntaxModuleIndicator === 1 /* CommonJS */ ? true : void 0,
+    impliedNodeFormat,
+    packageJsonScope,
+    statements: emptyArray,
+    imports: emptyArray
+  };
+}
 
 // src/services/exportInfoMap.ts
 var ImportKind = /* @__PURE__ */ ((ImportKind2) => {
@@ -152106,15 +152214,27 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
   const addToNamespace = [];
   const importType = [];
   const addToExisting = /* @__PURE__ */ new Map();
+  const removeExisting = /* @__PURE__ */ new Set();
+  const verbatimImports = /* @__PURE__ */ new Set();
   const newImports = /* @__PURE__ */ new Map();
-  return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes, hasFixes };
+  return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes, hasFixes, addImportForUnresolvedIdentifier, addImportForNonExistentExport, removeExistingImport, addVerbatimImport };
+  function addVerbatimImport(declaration) {
+    verbatimImports.add(declaration);
+  }
+  function addImportForUnresolvedIdentifier(context, symbolToken, useAutoImportProvider2) {
+    const info = getFixInfosWithoutDiagnostic(context, symbolToken, useAutoImportProvider2);
+    if (!info || !info.length)
+      return;
+    addImport(first(info));
+  }
   function addImportFromDiagnostic(diagnostic, context) {
     const info = getFixInfos(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
     if (!info || !info.length)
       return;
     addImport(first(info));
   }
-  function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite) {
+  function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite, referenceImport) {
+    var _a;
     const moduleSymbol = Debug.checkDefined(exportedSymbol.parent);
     const symbolName2 = getNameForExportedSymbol(exportedSymbol, getEmitScriptTarget(compilerOptions));
     const checker = program.getTypeChecker();
@@ -152132,7 +152252,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       cancellationToken
     );
     const useRequire = shouldUseRequire(sourceFile, program);
-    const fix = getImportFixForSymbol(
+    let fix = getImportFixForSymbol(
       sourceFile,
       Debug.checkDefined(exportInfo),
       program,
@@ -152144,9 +152264,72 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       preferences
     );
     if (fix) {
-      addImport({ fix, symbolName: symbolName2, errorIdentifierText: void 0 });
+      const localName = ((_a = tryCast(referenceImport == null ? void 0 : referenceImport.name, isIdentifier)) == null ? void 0 : _a.text) ?? symbolName2;
+      if (referenceImport && isTypeOnlyImportDeclaration(referenceImport) && (fix.kind === 3 /* AddNew */ || fix.kind === 2 /* AddToExisting */) && fix.addAsTypeOnly === 1 /* Allowed */) {
+        fix = { ...fix, addAsTypeOnly: 2 /* Required */ };
+      }
+      addImport({ fix, symbolName: localName ?? symbolName2, errorIdentifierText: void 0 });
+    }
+  }
+  function addImportForNonExistentExport(exportName, exportingFileName, exportKind, exportedMeanings, isImportUsageValidAsTypeOnly) {
+    const exportingSourceFile = program.getSourceFile(exportingFileName);
+    const useRequire = shouldUseRequire(sourceFile, program);
+    if (exportingSourceFile && exportingSourceFile.symbol) {
+      const { fixes } = getImportFixes(
+        [{
+          exportKind,
+          isFromPackageJson: false,
+          moduleFileName: exportingFileName,
+          moduleSymbol: exportingSourceFile.symbol,
+          targetFlags: exportedMeanings
+        }],
+        /*usagePosition*/
+        void 0,
+        isImportUsageValidAsTypeOnly,
+        useRequire,
+        program,
+        sourceFile,
+        host,
+        preferences
+      );
+      if (fixes.length) {
+        addImport({ fix: fixes[0], symbolName: exportName, errorIdentifierText: exportName });
+      }
+    } else {
+      const futureExportingSourceFile = createFutureSourceFile(exportingFileName, 99 /* ESNext */, program, host);
+      const moduleSpecifier = ts_moduleSpecifiers_exports.getLocalModuleSpecifierBetweenFileNames(
+        sourceFile,
+        exportingFileName,
+        compilerOptions,
+        createModuleSpecifierResolutionHost(program, host)
+      );
+      const importKind = getImportKind(futureExportingSourceFile, exportKind, compilerOptions);
+      const addAsTypeOnly = getAddAsTypeOnly(
+        isImportUsageValidAsTypeOnly,
+        /*isForNewImportDeclaration*/
+        true,
+        /*symbol*/
+        void 0,
+        exportedMeanings,
+        program.getTypeChecker(),
+        compilerOptions
+      );
+      const fix = {
+        kind: 3 /* AddNew */,
+        moduleSpecifier,
+        importKind,
+        addAsTypeOnly,
+        useRequire
+      };
+      addImport({ fix, symbolName: exportName, errorIdentifierText: exportName });
     }
   }
+  function removeExistingImport(declaration) {
+    if (declaration.kind === 273 /* ImportClause */) {
+      Debug.assertIsDefined(declaration.name, "ImportClause should have a name if it's being removed");
+    }
+    removeExisting.add(declaration);
+  }
   function addImport(info) {
     var _a, _b;
     const { fix, symbolName: symbolName2 } = info;
@@ -152159,10 +152342,9 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         break;
       case 2 /* AddToExisting */: {
         const { importClauseOrBindingPattern, importKind, addAsTypeOnly } = fix;
-        const key = String(getNodeId(importClauseOrBindingPattern));
-        let entry = addToExisting.get(key);
+        let entry = addToExisting.get(importClauseOrBindingPattern);
         if (!entry) {
-          addToExisting.set(key, entry = { importClauseOrBindingPattern, defaultImport: void 0, namedImports: /* @__PURE__ */ new Map() });
+          addToExisting.set(importClauseOrBindingPattern, entry = { importClauseOrBindingPattern, defaultImport: void 0, namedImports: /* @__PURE__ */ new Map() });
         }
         if (importKind === 0 /* Named */) {
           const prevValue = entry == null ? void 0 : entry.namedImports.get(symbolName2);
@@ -152244,8 +152426,9 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
     }
   }
   function writeFixes(changeTracker, oldFileQuotePreference) {
+    var _a, _b;
     let quotePreference;
-    if (sourceFile.imports.length === 0 && oldFileQuotePreference !== void 0) {
+    if (isFullSourceFile(sourceFile) && sourceFile.imports.length === 0 && oldFileQuotePreference !== void 0) {
       quotePreference = oldFileQuotePreference;
     } else {
       quotePreference = getQuotePreference(sourceFile, preferences);
@@ -152256,6 +152439,82 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
     for (const fix of importType) {
       addImportType(changeTracker, sourceFile, fix, quotePreference);
     }
+    let importSpecifiersToRemoveWhileAdding;
+    if (removeExisting.size) {
+      Debug.assert(isFullSourceFile(sourceFile), "Cannot remove imports from a future source file");
+      const importDeclarationsWithRemovals = new Set(mapDefined([...removeExisting], (d) => findAncestor(d, isImportDeclaration)));
+      const variableDeclarationsWithRemovals = new Set(mapDefined([...removeExisting], (d) => findAncestor(d, isVariableDeclarationInitializedToRequire)));
+      const emptyImportDeclarations = [...importDeclarationsWithRemovals].filter(
+        (d) => {
+          var _a2, _b2, _c;
+          return (
+            // nothing added to the import declaration
+            !addToExisting.has(d.importClause) && // no default, or default is being removed
+            (!((_a2 = d.importClause) == null ? void 0 : _a2.name) || removeExisting.has(d.importClause)) && // no namespace import, or namespace import is being removed
+            (!tryCast((_b2 = d.importClause) == null ? void 0 : _b2.namedBindings, isNamespaceImport) || removeExisting.has(d.importClause.namedBindings)) && // no named imports, or all named imports are being removed
+            (!tryCast((_c = d.importClause) == null ? void 0 : _c.namedBindings, isNamedImports) || every(d.importClause.namedBindings.elements, (e) => removeExisting.has(e)))
+          );
+        }
+      );
+      const emptyVariableDeclarations = [...variableDeclarationsWithRemovals].filter(
+        (d) => (
+          // no binding elements being added to the variable declaration
+          (d.name.kind !== 206 /* ObjectBindingPattern */ || !addToExisting.has(d.name)) && // no binding elements, or all binding elements are being removed
+          (d.name.kind !== 206 /* ObjectBindingPattern */ || every(d.name.elements, (e) => removeExisting.has(e)))
+        )
+      );
+      const namedBindingsToDelete = [...importDeclarationsWithRemovals].filter(
+        (d) => {
+          var _a2, _b2;
+          return (
+            // has named bindings
+            ((_a2 = d.importClause) == null ? void 0 : _a2.namedBindings) && // is not being fully removed
+            emptyImportDeclarations.indexOf(d) === -1 && // is not gaining named imports
+            !((_b2 = addToExisting.get(d.importClause)) == null ? void 0 : _b2.namedImports) && // all named imports are being removed
+            (d.importClause.namedBindings.kind === 274 /* NamespaceImport */ || every(d.importClause.namedBindings.elements, (e) => removeExisting.has(e)))
+          );
+        }
+      );
+      for (const declaration of [...emptyImportDeclarations, ...emptyVariableDeclarations]) {
+        changeTracker.delete(sourceFile, declaration);
+      }
+      for (const declaration of namedBindingsToDelete) {
+        changeTracker.replaceNode(
+          sourceFile,
+          declaration.importClause,
+          factory.updateImportClause(
+            declaration.importClause,
+            declaration.importClause.isTypeOnly,
+            declaration.importClause.name,
+            /*namedBindings*/
+            void 0
+          )
+        );
+      }
+      for (const declaration of removeExisting) {
+        const importDeclaration = findAncestor(declaration, isImportDeclaration);
+        if (importDeclaration && emptyImportDeclarations.indexOf(importDeclaration) === -1 && namedBindingsToDelete.indexOf(importDeclaration) === -1) {
+          if (declaration.kind === 273 /* ImportClause */) {
+            changeTracker.delete(sourceFile, declaration.name);
+          } else {
+            Debug.assert(declaration.kind === 276 /* ImportSpecifier */, "NamespaceImport should have been handled earlier");
+            if ((_a = addToExisting.get(importDeclaration.importClause)) == null ? void 0 : _a.namedImports) {
+              (importSpecifiersToRemoveWhileAdding ?? (importSpecifiersToRemoveWhileAdding = /* @__PURE__ */ new Set())).add(declaration);
+            } else {
+              changeTracker.delete(sourceFile, declaration);
+            }
+          }
+        } else if (declaration.kind === 208 /* BindingElement */) {
+          if ((_b = addToExisting.get(declaration.parent)) == null ? void 0 : _b.namedImports) {
+            (importSpecifiersToRemoveWhileAdding ?? (importSpecifiersToRemoveWhileAdding = /* @__PURE__ */ new Set())).add(declaration);
+          } else {
+            changeTracker.delete(sourceFile, declaration);
+          }
+        } else if (declaration.kind === 271 /* ImportEqualsDeclaration */) {
+          changeTracker.delete(sourceFile, declaration);
+        }
+      }
+    }
     addToExisting.forEach(({ importClauseOrBindingPattern, defaultImport, namedImports }) => {
       doAddExistingFix(
         changeTracker,
@@ -152263,6 +152522,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         importClauseOrBindingPattern,
         defaultImport,
         arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
+        importSpecifiersToRemoveWhileAdding,
         preferences
       );
     });
@@ -152281,6 +152541,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       );
       newDeclarations = combine(newDeclarations, declarations);
     });
+    newDeclarations = combine(newDeclarations, getCombinedVerbatimImports());
     if (newDeclarations) {
       insertImports(
         changeTracker,
@@ -152292,8 +152553,85 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       );
     }
   }
+  function getCombinedVerbatimImports() {
+    if (!verbatimImports.size)
+      return void 0;
+    const importDeclarations = new Set(mapDefined([...verbatimImports], (d) => findAncestor(d, isImportDeclaration)));
+    const requireStatements = new Set(mapDefined([...verbatimImports], (d) => findAncestor(d, isRequireVariableStatement)));
+    return [
+      ...mapDefined([...verbatimImports], (d) => d.kind === 271 /* ImportEqualsDeclaration */ ? getSynthesizedDeepClone(
+        d,
+        /*includeTrivia*/
+        true
+      ) : void 0),
+      ...[...importDeclarations].map((d) => {
+        var _a;
+        if (verbatimImports.has(d)) {
+          return getSynthesizedDeepClone(
+            d,
+            /*includeTrivia*/
+            true
+          );
+        }
+        return getSynthesizedDeepClone(
+          factory.updateImportDeclaration(
+            d,
+            d.modifiers,
+            d.importClause && factory.updateImportClause(
+              d.importClause,
+              d.importClause.isTypeOnly,
+              verbatimImports.has(d.importClause) ? d.importClause.name : void 0,
+              verbatimImports.has(d.importClause.namedBindings) ? d.importClause.namedBindings : ((_a = tryCast(d.importClause.namedBindings, isNamedImports)) == null ? void 0 : _a.elements.some((e) => verbatimImports.has(e))) ? factory.updateNamedImports(
+                d.importClause.namedBindings,
+                d.importClause.namedBindings.elements.filter((e) => verbatimImports.has(e))
+              ) : void 0
+            ),
+            d.moduleSpecifier,
+            d.attributes
+          ),
+          /*includeTrivia*/
+          true
+        );
+      }),
+      ...[...requireStatements].map((s) => {
+        if (verbatimImports.has(s)) {
+          return getSynthesizedDeepClone(
+            s,
+            /*includeTrivia*/
+            true
+          );
+        }
+        return getSynthesizedDeepClone(
+          factory.updateVariableStatement(
+            s,
+            s.modifiers,
+            factory.updateVariableDeclarationList(
+              s.declarationList,
+              mapDefined(s.declarationList.declarations, (d) => {
+                if (verbatimImports.has(d)) {
+                  return d;
+                }
+                return factory.updateVariableDeclaration(
+                  d,
+                  d.name.kind === 206 /* ObjectBindingPattern */ ? factory.updateObjectBindingPattern(
+                    d.name,
+                    d.name.elements.filter((e) => verbatimImports.has(e))
+                  ) : d.name,
+                  d.exclamationToken,
+                  d.type,
+                  d.initializer
+                );
+              })
+            )
+          ),
+          /*includeTrivia*/
+          true
+        );
+      })
+    ];
+  }
   function hasFixes() {
-    return addToNamespace.length > 0 || importType.length > 0 || addToExisting.size > 0 || newImports.size > 0;
+    return addToNamespace.length > 0 || importType.length > 0 || addToExisting.size > 0 || newImports.size > 0 || verbatimImports.size > 0 || removeExisting.size > 0;
   }
 }
 function createImportSpecifierResolver(importingFile, program, host, preferences) {
@@ -152402,9 +152740,12 @@ function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program
     }
   }
 }
-function getImportFixes(exportInfos, usagePosition, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap = createExistingImportMap(program.getTypeChecker(), sourceFile, program.getCompilerOptions()), fromCacheOnly) {
+function isFutureSymbolExportInfoArray(info) {
+  return info[0].symbol === void 0;
+}
+function getImportFixes(exportInfos, usagePosition, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap = isFullSourceFile(sourceFile) ? createExistingImportMap(program.getTypeChecker(), sourceFile, program.getCompilerOptions()) : void 0, fromCacheOnly) {
   const checker = program.getTypeChecker();
-  const existingImports = flatMap(exportInfos, importMap.getImportsForExportInfo);
+  const existingImports = importMap && !isFutureSymbolExportInfoArray(exportInfos) ? flatMap(exportInfos, importMap.getImportsForExportInfo) : emptyArray;
   const useNamespace = usagePosition !== void 0 && tryUseExistingNamespaceImport(existingImports, usagePosition);
   const addToExisting = tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, program.getCompilerOptions());
   if (addToExisting) {
@@ -152460,7 +152801,7 @@ function getAddAsTypeOnly(isValidTypeOnlyUseSite, isForNewImportDeclaration, sym
   if (!isValidTypeOnlyUseSite) {
     return 4 /* NotAllowed */;
   }
-  if (compilerOptions.verbatimModuleSyntax && (!(targetFlags & 111551 /* Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) {
+  if (symbol && compilerOptions.verbatimModuleSyntax && (!(targetFlags & 111551 /* Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) {
     return 2 /* Required */;
   }
   return 1 /* Allowed */;
@@ -152547,7 +152888,7 @@ function createExistingImportMap(checker, importingFile, compilerOptions) {
   };
 }
 function shouldUseRequire(sourceFile, program) {
-  if (!isSourceFileJS(sourceFile)) {
+  if (!hasJSFileExtension(sourceFile.fileName)) {
     return false;
   }
   if (sourceFile.commonJsModuleIndicator && !sourceFile.externalModuleIndicator)
@@ -152576,14 +152917,14 @@ function createGetChecker(program, host) {
   return memoizeOne((isFromPackageJson) => isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker());
 }
 function getNewImportFixes(program, sourceFile, usagePosition, isValidTypeOnlyUseSite, useRequire, exportInfo, host, preferences, fromCacheOnly) {
-  const isJs = isSourceFileJS(sourceFile);
+  const isJs = hasJSFileExtension(sourceFile.fileName);
   const compilerOptions = program.getCompilerOptions();
   const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host);
   const getChecker = createGetChecker(program, host);
   const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
   const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(moduleResolution);
-  const getModuleSpecifiers2 = fromCacheOnly ? (moduleSymbol) => ({ moduleSpecifiers: ts_moduleSpecifiers_exports.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }) : (moduleSymbol, checker) => ts_moduleSpecifiers_exports.getModuleSpecifiersWithCacheInfo(
-    moduleSymbol,
+  const getModuleSpecifiers2 = fromCacheOnly ? (exportInfo2) => ({ moduleSpecifiers: ts_moduleSpecifiers_exports.tryGetModuleSpecifiersFromCache(exportInfo2.moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }) : (exportInfo2, checker) => ts_moduleSpecifiers_exports.getModuleSpecifiersWithCacheInfo(
+    exportInfo2.moduleSymbol,
     checker,
     compilerOptions,
     sourceFile,
@@ -152597,7 +152938,7 @@ function getNewImportFixes(program, sourceFile, usagePosition, isValidTypeOnlyUs
   let computedWithoutCacheCount = 0;
   const fixes = flatMap(exportInfo, (exportInfo2, i) => {
     const checker = getChecker(exportInfo2.isFromPackageJson);
-    const { computedWithoutCache, moduleSpecifiers } = getModuleSpecifiers2(exportInfo2.moduleSymbol, checker);
+    const { computedWithoutCache, moduleSpecifiers } = getModuleSpecifiers2(exportInfo2, checker);
     const importedSymbolHasValueMeaning = !!(exportInfo2.targetFlags & 111551 /* Value */);
     const addAsTypeOnly = getAddAsTypeOnly(
       isValidTypeOnlyUseSite,
@@ -152688,6 +153029,11 @@ function sortFixInfo(fixes, sourceFile, program, packageJsonImportFilter, host)
   const _toPath = (fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
   return sort(fixes, (a, b) => compareBooleans(!!a.isJsxNamespaceFix, !!b.isJsxNamespaceFix) || compareValues(a.fix.kind, b.fix.kind) || compareModuleSpecifiers(a.fix, b.fix, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath));
 }
+function getFixInfosWithoutDiagnostic(context, symbolToken, useAutoImportProvider) {
+  const info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
+  const packageJsonImportFilter = createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
+  return info && sortFixInfo(info, context.sourceFile, context.program, packageJsonImportFilter, context.host);
+}
 function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) {
   if (!some(fixes))
     return;
@@ -152711,17 +153057,17 @@ function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) {
 function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier, toPath3) {
   if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
     return compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier)) || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program) || compareBooleans(
-      isFixPossiblyReExportingImportingFile(a, importingFile, program.getCompilerOptions(), toPath3),
-      isFixPossiblyReExportingImportingFile(b, importingFile, program.getCompilerOptions(), toPath3)
+      isFixPossiblyReExportingImportingFile(a, importingFile.path, toPath3),
+      isFixPossiblyReExportingImportingFile(b, importingFile.path, toPath3)
     ) || compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
   }
   return 0 /* EqualTo */;
 }
-function isFixPossiblyReExportingImportingFile(fix, importingFile, compilerOptions, toPath3) {
+function isFixPossiblyReExportingImportingFile(fix, importingFilePath, toPath3) {
   var _a;
   if (fix.isReExport && ((_a = fix.exportInfo) == null ? void 0 : _a.moduleFileName) && isIndexFileName(fix.exportInfo.moduleFileName)) {
     const reExportDir = toPath3(getDirectoryPath(fix.exportInfo.moduleFileName));
-    return startsWith(importingFile.path, reExportDir);
+    return startsWith(importingFilePath, reExportDir);
   }
   return false;
 }
@@ -152811,8 +153157,8 @@ function getUmdImportKind(importingFile, compilerOptions, forceImportKeyword) {
     case 2 /* AMD */:
     case 1 /* CommonJS */:
     case 3 /* UMD */:
-      if (isInJSFile(importingFile)) {
-        return isExternalModule(importingFile) || forceImportKeyword ? 2 /* Namespace */ : 3 /* CommonJS */;
+      if (hasJSFileExtension(importingFile.fileName)) {
+        return importingFile.externalModuleIndicator || forceImportKeyword ? 2 /* Namespace */ : 3 /* CommonJS */;
       }
       return 3 /* CommonJS */;
     case 4 /* System */:
@@ -152923,14 +153269,14 @@ function getExportInfos(symbolName2, isJsxTagName, currentTokenMeaning, cancella
 }
 function getExportEqualsImportKind(importingFile, compilerOptions, forceImportKeyword) {
   const allowSyntheticDefaults = getAllowSyntheticDefaultImports(compilerOptions);
-  const isJS = isInJSFile(importingFile);
+  const isJS = hasJSFileExtension(importingFile.fileName);
   if (!isJS && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */) {
     return allowSyntheticDefaults ? 1 /* Default */ : 2 /* Namespace */;
   }
   if (isJS) {
-    return isExternalModule(importingFile) || forceImportKeyword ? allowSyntheticDefaults ? 1 /* Default */ : 2 /* Namespace */ : 3 /* CommonJS */;
+    return importingFile.externalModuleIndicator || forceImportKeyword ? allowSyntheticDefaults ? 1 /* Default */ : 2 /* Namespace */ : 3 /* CommonJS */;
   }
-  for (const statement of importingFile.statements) {
+  for (const statement of importingFile.statements ?? emptyArray) {
     if (isImportEqualsDeclaration(statement) && !nodeIsMissing(statement.moduleReference)) {
       return 3 /* CommonJS */;
     }
@@ -152961,6 +153307,8 @@ function codeActionForFixWorker(changes, sourceFile, symbolName2, fix, includeSy
         importClauseOrBindingPattern,
         importKind === 1 /* Default */ ? { name: symbolName2, addAsTypeOnly } : void 0,
         importKind === 0 /* Named */ ? [{ name: symbolName2, addAsTypeOnly }] : emptyArray,
+        /*removeExistingImportSpecifiers*/
+        void 0,
         preferences
       );
       const moduleSpecifierWithoutQuotes = stripQuotes(moduleSpecifier);
@@ -153075,9 +153423,33 @@ function promoteFromTypeOnly(changes, aliasDeclaration, program, sourceFile, pre
     }
   }
 }
-function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, preferences) {
+function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, removeExistingImportSpecifiers, preferences) {
   var _a;
   if (clause.kind === 206 /* ObjectBindingPattern */) {
+    if (removeExistingImportSpecifiers && clause.elements.some((e) => removeExistingImportSpecifiers.has(e))) {
+      changes.replaceNode(
+        sourceFile,
+        clause,
+        factory.createObjectBindingPattern([
+          ...clause.elements.filter((e) => !removeExistingImportSpecifiers.has(e)),
+          ...defaultImport ? [factory.createBindingElement(
+            /*dotDotDotToken*/
+            void 0,
+            /*propertyName*/
+            "default",
+            defaultImport.name
+          )] : emptyArray,
+          ...namedImports.map((i) => factory.createBindingElement(
+            /*dotDotDotToken*/
+            void 0,
+            /*propertyName*/
+            void 0,
+            i.name
+          ))
+        ])
+      );
+      return;
+    }
     if (defaultImport) {
       addElementToBindingPattern(clause, defaultImport.name, "default");
     }
@@ -153110,7 +153482,16 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor
       ),
       specifierComparer
     );
-    if ((existingSpecifiers == null ? void 0 : existingSpecifiers.length) && isSorted !== false) {
+    if (removeExistingImportSpecifiers) {
+      changes.replaceNode(
+        sourceFile,
+        clause.namedBindings,
+        factory.updateNamedImports(
+          clause.namedBindings,
+          stableSort([...existingSpecifiers.filter((s) => !removeExistingImportSpecifiers.has(s)), ...newSpecifiers], specifierComparer)
+        )
+      );
+    } else if ((existingSpecifiers == null ? void 0 : existingSpecifiers.length) && isSorted !== false) {
       const transformedExistingSpecifiers = promoteFromTypeOnly2 && existingSpecifiers ? factory.updateNamedImports(
         clause.namedBindings,
         sameMap(existingSpecifiers, (e) => factory.updateImportSpecifier(
@@ -161946,13 +162327,13 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
               ({ exportInfo: exportInfo2 = info[0], moduleSpecifier } = result);
             }
             const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
-            const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;
+            const symbol = isDefaultExport && getLocalSymbolForExportDefault(Debug.checkDefined(exportInfo2.symbol)) || Debug.checkDefined(exportInfo2.symbol);
             pushAutoImportSymbol(symbol, {
               kind: moduleSpecifier ? 32 /* ResolvedExport */ : 4 /* Export */,
               moduleSpecifier,
               symbolName: symbolName2,
               exportMapKey,
-              exportName: exportInfo2.exportKind === 2 /* ExportEquals */ ? "export=" /* ExportEquals */ : exportInfo2.symbol.name,
+              exportName: exportInfo2.exportKind === 2 /* ExportEquals */ ? "export=" /* ExportEquals */ : Debug.checkDefined(exportInfo2.symbol).name,
               fileName: exportInfo2.moduleFileName,
               isDefaultExport,
               moduleSymbol: exportInfo2.moduleSymbol,
@@ -175406,6 +175787,7 @@ __export(ts_exports2, {
   createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
   createFlowNode: () => createFlowNode,
   createForOfBindingStatement: () => createForOfBindingStatement,
+  createFutureSourceFile: () => createFutureSourceFile,
   createGetCanonicalFileName: () => createGetCanonicalFileName,
   createGetSourceFile: () => createGetSourceFile,
   createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
@@ -176177,6 +176559,7 @@ __export(ts_exports2, {
   isAnyDirectorySeparator: () => isAnyDirectorySeparator,
   isAnyImportOrBareOrAccessedRequire: () => isAnyImportOrBareOrAccessedRequire,
   isAnyImportOrReExport: () => isAnyImportOrReExport,
+  isAnyImportOrRequireStatement: () => isAnyImportOrRequireStatement,
   isAnyImportSyntax: () => isAnyImportSyntax,
   isAnySupportedFileExtension: () => isAnySupportedFileExtension,
   isApplicableVersionedTypesKey: () => isApplicableVersionedTypesKey,
@@ -176367,6 +176750,7 @@ __export(ts_exports2, {
   isForInitializer: () => isForInitializer,
   isForOfStatement: () => isForOfStatement,
   isForStatement: () => isForStatement,
+  isFullSourceFile: () => isFullSourceFile,
   isFunctionBlock: () => isFunctionBlock,
   isFunctionBody: () => isFunctionBody,
   isFunctionDeclaration: () => isFunctionDeclaration,
@@ -181122,6 +181506,13 @@ var ConfiguredProject2 = class extends Project3 {
     this.compilerHost = void 0;
     this.projectService.sendProjectLoadingFinishEvent(this);
     this.projectService.sendProjectTelemetry(this);
+    if (!this.skipConfigDiagEvent && !result) {
+      this.projectService.sendConfigFileDiagEvent(
+        this,
+        /*triggerFile*/
+        void 0
+      );
+    }
     return result;
   }
   /** @internal */
@@ -181576,7 +181967,12 @@ function projectContainsInfoDirectly(project, info) {
 }
 function updateProjectIfDirty(project) {
   project.invalidateResolutionsOfFailedLookupLocations();
-  return project.dirty && project.updateGraph();
+  return project.dirty && !project.updateGraph();
+}
+function updateConfiguredProjectWithoutConfigDiagIfDirty(project) {
+  project.skipConfigDiagEvent = true;
+  updateProjectIfDirty(project);
+  project.skipConfigDiagEvent = void 0;
 }
 function setProjectOptionsUsed(project) {
   if (isConfiguredProject(project)) {
@@ -182868,6 +183264,7 @@ var _ProjectService = class _ProjectService {
   /** @internal */
   createLoadAndUpdateConfiguredProject(configFileName, reason) {
     const project = this.createAndLoadConfiguredProject(configFileName, reason);
+    project.skipConfigDiagEvent = true;
     project.updateGraph();
     return project;
   }
@@ -183160,6 +183557,7 @@ var _ProjectService = class _ProjectService {
     const configFileName = project.getConfigFilePath();
     this.logger.info(`${isInitialLoad ? "Loading" : "Reloading"} configured project ${configFileName}`);
     this.loadConfiguredProject(project, reason);
+    project.skipConfigDiagEvent = true;
     project.updateGraph();
     this.sendConfigFileDiagEvent(project, configFileName);
   }
@@ -183173,16 +183571,20 @@ var _ProjectService = class _ProjectService {
     project.cleanupProgram();
     project.markAsDirty();
   }
+  /** @internal */
   sendConfigFileDiagEvent(project, triggerFile) {
     if (!this.eventHandler || this.suppressDiagnosticEvents) {
       return;
     }
     const diagnostics = project.getLanguageService().getCompilerOptionsDiagnostics();
     diagnostics.push(...project.getAllProjectErrors());
+    if (!triggerFile && !!diagnostics.length === !!project.hasConfigFileDiagnostics)
+      return;
+    project.hasConfigFileDiagnostics = !!diagnostics.length;
     this.eventHandler(
       {
         eventName: ConfigFileDiagEvent,
-        data: { configFileName: project.getConfigFilePath(), diagnostics, triggerFile }
+        data: { configFileName: project.getConfigFilePath(), diagnostics, triggerFile: triggerFile ?? project.getConfigFilePath() }
       }
     );
   }
@@ -183972,7 +184374,7 @@ Dynamic files must always be opened with service's current directory or service
           project = this.createLoadAndUpdateConfiguredProject(configFileName, `Creating possible configured project for ${info.fileName} to open`);
           defaultConfigProjectIsCreated = true;
         } else {
-          updateProjectIfDirty(project);
+          updateConfiguredProjectWithoutConfigDiagIfDirty(project);
         }
         projectForConfigFileDiag = project.containsScriptInfo(info) ? project : void 0;
         retainProjects = project;
@@ -183981,7 +184383,7 @@ Dynamic files must always be opened with service's current directory or service
             project,
             info.path,
             (child) => {
-              updateProjectIfDirty(child);
+              updateConfiguredProjectWithoutConfigDiagIfDirty(child);
               if (!isArray(retainProjects)) {
                 retainProjects = [project, child];
               } else {
@@ -189629,6 +190031,7 @@ if (typeof console !== "undefined") {
   createFileDiagnosticFromMessageChain,
   createFlowNode,
   createForOfBindingStatement,
+  createFutureSourceFile,
   createGetCanonicalFileName,
   createGetSourceFile,
   createGetSymbolAccessibilityDiagnosticForNode,
@@ -190400,6 +190803,7 @@ if (typeof console !== "undefined") {
   isAnyDirectorySeparator,
   isAnyImportOrBareOrAccessedRequire,
   isAnyImportOrReExport,
+  isAnyImportOrRequireStatement,
   isAnyImportSyntax,
   isAnySupportedFileExtension,
   isApplicableVersionedTypesKey,
@@ -190590,6 +190994,7 @@ if (typeof console !== "undefined") {
   isForInitializer,
   isForOfStatement,
   isForStatement,
+  isFullSourceFile,
   isFunctionBlock,
   isFunctionBody,
   isFunctionDeclaration,