typescript 5.5.0-dev.20240409 → 5.5.0-dev.20240410

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240409`;
+var version = `${versionMajorMinor}.0-dev.20240410`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -13397,6 +13397,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);
 }
@@ -17038,12 +17041,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 */) {
@@ -42665,7 +42668,7 @@ function getModuleSpecifierPreferences({ importModuleSpecifierPreference, import
       importModuleSpecifierEnding,
       resolutionMode ?? importingSourceFile.impliedNodeFormat,
       compilerOptions,
-      importingSourceFile
+      isFullSourceFile(importingSourceFile) ? importingSourceFile : void 0
     );
   }
 }
@@ -42725,7 +42728,7 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
 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)
@@ -55717,13 +55720,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);
         }

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-dev.20240409`;
+var version = `${versionMajorMinor}.0-dev.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)
@@ -60486,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);
         }
@@ -134688,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 */;
   }
 }
@@ -134746,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) {
@@ -135679,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);
       }
@@ -135986,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) => {
@@ -152163,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();
@@ -152189,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,
@@ -152201,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;
@@ -152216,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);
@@ -152301,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);
@@ -152313,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,
@@ -152320,6 +152522,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         importClauseOrBindingPattern,
         defaultImport,
         arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
+        importSpecifiersToRemoveWhileAdding,
         preferences
       );
     });
@@ -152338,6 +152541,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       );
       newDeclarations = combine(newDeclarations, declarations);
     });
+    newDeclarations = combine(newDeclarations, getCombinedVerbatimImports());
     if (newDeclarations) {
       insertImports(
         changeTracker,
@@ -152349,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) {
@@ -152459,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) {
@@ -152517,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 */;
@@ -152604,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)
@@ -152633,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,
@@ -152654,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,
@@ -152745,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;
@@ -152768,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;
 }
@@ -152868,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 */:
@@ -152980,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 */;
     }
@@ -153018,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);
@@ -153132,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");
     }
@@ -153167,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(
@@ -162003,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,
@@ -175463,6 +175787,7 @@ __export(ts_exports2, {
   createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
   createFlowNode: () => createFlowNode,
   createForOfBindingStatement: () => createForOfBindingStatement,
+  createFutureSourceFile: () => createFutureSourceFile,
   createGetCanonicalFileName: () => createGetCanonicalFileName,
   createGetSourceFile: () => createGetSourceFile,
   createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
@@ -176234,6 +176559,7 @@ __export(ts_exports2, {
   isAnyDirectorySeparator: () => isAnyDirectorySeparator,
   isAnyImportOrBareOrAccessedRequire: () => isAnyImportOrBareOrAccessedRequire,
   isAnyImportOrReExport: () => isAnyImportOrReExport,
+  isAnyImportOrRequireStatement: () => isAnyImportOrRequireStatement,
   isAnyImportSyntax: () => isAnyImportSyntax,
   isAnySupportedFileExtension: () => isAnySupportedFileExtension,
   isApplicableVersionedTypesKey: () => isApplicableVersionedTypesKey,
@@ -176424,6 +176750,7 @@ __export(ts_exports2, {
   isForInitializer: () => isForInitializer,
   isForOfStatement: () => isForOfStatement,
   isForStatement: () => isForStatement,
+  isFullSourceFile: () => isFullSourceFile,
   isFunctionBlock: () => isFunctionBlock,
   isFunctionBody: () => isFunctionBody,
   isFunctionDeclaration: () => isFunctionDeclaration,
@@ -189704,6 +190031,7 @@ if (typeof console !== "undefined") {
   createFileDiagnosticFromMessageChain,
   createFlowNode,
   createForOfBindingStatement,
+  createFutureSourceFile,
   createGetCanonicalFileName,
   createGetSourceFile,
   createGetSymbolAccessibilityDiagnosticForNode,
@@ -190475,6 +190803,7 @@ if (typeof console !== "undefined") {
   isAnyDirectorySeparator,
   isAnyImportOrBareOrAccessedRequire,
   isAnyImportOrReExport,
+  isAnyImportOrRequireStatement,
   isAnyImportSyntax,
   isAnySupportedFileExtension,
   isApplicableVersionedTypesKey,
@@ -190665,6 +190994,7 @@ if (typeof console !== "undefined") {
   isForInitializer,
   isForOfStatement,
   isForStatement,
+  isFullSourceFile,
   isFunctionBlock,
   isFunctionBody,
   isFunctionDeclaration,

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.5.0-dev.20240409",
+    "version": "5.5.0-dev.20240410",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -111,5 +111,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "7a4cbfa7ea8c6b7a09a84d04bd7e45c815e8e0d1"
+    "gitHead": "b6351c61363f7ed11f160f1b54183a905335bcea"
 }