typescript 5.5.0-dev.20240320 → 5.5.0-dev.20240322

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.20240320`;
+var version = `${versionMajorMinor}.0-dev.20240322`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3880,7 +3880,8 @@ var commentPragmas = {
       { name: "lib", optional: true, captureSpan: true },
       { name: "path", optional: true, captureSpan: true },
       { name: "no-default-lib", optional: true },
-      { name: "resolution-mode", optional: true }
+      { name: "resolution-mode", optional: true },
+      { name: "preserve", optional: true }
     ],
     kind: 1 /* TripleSlashXML */
   },
@@ -7792,7 +7793,9 @@ var Diagnostics = {
   The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."),
   Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."),
   Its_type_0_is_not_a_valid_JSX_element_type: diag(18053, 1 /* Error */, "Its_type_0_is_not_a_valid_JSX_element_type_18053", "Its type '{0}' is not a valid JSX element type."),
-  await_using_statements_cannot_be_used_inside_a_class_static_block: diag(18054, 1 /* Error */, "await_using_statements_cannot_be_used_inside_a_class_static_block_18054", "'await using' statements cannot be used inside a class static block.")
+  await_using_statements_cannot_be_used_inside_a_class_static_block: diag(18054, 1 /* Error */, "await_using_statements_cannot_be_used_inside_a_class_static_block_18054", "'await using' statements cannot be used inside a class static block."),
+  _0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled: diag(18055, 1 /* Error */, "_0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is__18055", "'{0}' has a string type, but must have syntactically recognizable string syntax when 'isolatedModules' is enabled."),
+  Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled: diag(18056, 1 /* Error */, "Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is__18056", "Enum member following a non-literal numeric member must have an initializer when 'isolatedModules' is enabled.")
 };
 
 // src/compiler/scanner.ts
@@ -32546,7 +32549,7 @@ var Parser;
               80 /* Identifier */,
               /*reportAtCurrentPosition*/
               false
-            ) : parseIdentifier()), pos);
+            ) : parseIdentifierName()), pos);
           }
           while (token() === 81 /* PrivateIdentifier */) {
             reScanHashToken();
@@ -33494,16 +33497,17 @@ function processPragmasIntoFields(context, reportDiagnostic) {
         const typeReferenceDirectives = context.typeReferenceDirectives;
         const libReferenceDirectives = context.libReferenceDirectives;
         forEach(toArray(entryOrList), (arg) => {
-          const { types, lib, path, ["resolution-mode"]: res } = arg.arguments;
+          const { types, lib, path, ["resolution-mode"]: res, preserve: _preserve } = arg.arguments;
+          const preserve = _preserve === "true" ? true : void 0;
           if (arg.arguments["no-default-lib"] === "true") {
             context.hasNoDefaultLib = true;
           } else if (types) {
             const parsed = parseResolutionMode(res, types.pos, types.end, reportDiagnostic);
-            typeReferenceDirectives.push({ pos: types.pos, end: types.end, fileName: types.value, ...parsed ? { resolutionMode: parsed } : {} });
+            typeReferenceDirectives.push({ pos: types.pos, end: types.end, fileName: types.value, ...parsed ? { resolutionMode: parsed } : {}, ...preserve ? { preserve } : {} });
           } else if (lib) {
-            libReferenceDirectives.push({ pos: lib.pos, end: lib.end, fileName: lib.value });
+            libReferenceDirectives.push({ pos: lib.pos, end: lib.end, fileName: lib.value, ...preserve ? { preserve } : {} });
           } else if (path) {
-            referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value });
+            referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value, ...preserve ? { preserve } : {} });
           } else {
             reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
           }
@@ -42308,24 +42312,6 @@ function getModuleSpecifierPreferences({ importModuleSpecifierPreference, import
     );
   }
 }
-function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, options = {}) {
-  return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getModuleSpecifierPreferences({}, compilerOptions, importingSourceFile), {}, options);
-}
-function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, preferences, userPreferences, options = {}) {
-  const info = getInfo(importingSourceFileName, host);
-  const modulePaths = getAllModulePaths(info, toFileName2, host, userPreferences, options);
-  return firstDefined(modulePaths, (modulePath) => tryGetModuleNameAsNodeModule(
-    modulePath,
-    info,
-    importingSourceFile,
-    host,
-    compilerOptions,
-    userPreferences,
-    /*packageNameOnly*/
-    void 0,
-    options.overrideImportMode
-  )) || getLocalModuleSpecifier(toFileName2, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
-}
 function tryGetModuleSpecifiersFromCacheWorker(moduleSymbol, importingSourceFile, host, userPreferences, options = {}) {
   var _a;
   const moduleSourceFile = getSourceFileOfModule(moduleSymbol);
@@ -42562,22 +42548,6 @@ function forEachFileNameOfModule(importingFileName, importedFileName, host, pref
   });
   return result || (preferSymlinks ? forEach(targets, (p) => shouldFilterIgnoredPaths && containsIgnoredPath(p) ? void 0 : cb(p, p === referenceRedirect)) : void 0);
 }
-function getAllModulePaths(info, importedFileName, host, preferences, options = {}) {
-  var _a;
-  const importingFilePath = toPath(info.importingSourceFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
-  const importedFilePath = toPath(importedFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
-  const cache = (_a = host.getModuleSpecifierCache) == null ? void 0 : _a.call(host);
-  if (cache) {
-    const cached = cache.get(importingFilePath, importedFilePath, preferences, options);
-    if (cached == null ? void 0 : cached.modulePaths)
-      return cached.modulePaths;
-  }
-  const modulePaths = getAllModulePathsWorker(info, importedFileName, host);
-  if (cache) {
-    cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
-  }
-  return modulePaths;
-}
 function getAllModulePathsWorker(info, importedFileName, host) {
   const allFileNames = /* @__PURE__ */ new Map();
   let importedFileFromNodeModules = false;
@@ -43591,12 +43561,9 @@ function createTypeChecker(host) {
     getExactOptionalProperties,
     getAllPossiblePropertiesOfTypes,
     getSuggestedSymbolForNonexistentProperty,
-    getSuggestionForNonexistentProperty,
     getSuggestedSymbolForNonexistentJSXAttribute,
     getSuggestedSymbolForNonexistentSymbol: (location, name, meaning) => getSuggestedSymbolForNonexistentSymbol(location, escapeLeadingUnderscores(name), meaning),
-    getSuggestionForNonexistentSymbol: (location, name, meaning) => getSuggestionForNonexistentSymbol(location, escapeLeadingUnderscores(name), meaning),
     getSuggestedSymbolForNonexistentModule,
-    getSuggestionForNonexistentExport,
     getSuggestedSymbolForNonexistentClassMember,
     getBaseConstraintOfType,
     getDefaultFromTypeParameter: (type) => type && type.flags & 262144 /* TypeParameter */ ? getDefaultFromTypeParameter(type) : void 0,
@@ -47624,15 +47591,19 @@ function createTypeChecker(host) {
       return true;
     }
   }
-  function isEntityNameVisible(entityName, enclosingDeclaration) {
+  function getMeaningOfEntityNameReference(entityName) {
     let meaning;
     if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */) {
       meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
-    } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */) {
+    } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */ || entityName.parent.kind === 166 /* QualifiedName */ && entityName.parent.left === entityName || entityName.parent.kind === 211 /* PropertyAccessExpression */ && entityName.parent.expression === entityName || entityName.parent.kind === 212 /* ElementAccessExpression */ && entityName.parent.expression === entityName) {
       meaning = 1920 /* Namespace */;
     } else {
       meaning = 788968 /* Type */;
     }
+    return meaning;
+  }
+  function isEntityNameVisible(entityName, enclosingDeclaration) {
+    const meaning = getMeaningOfEntityNameReference(entityName);
     const firstIdentifier = getFirstIdentifier(entityName);
     const symbol = resolveName(
       enclosingDeclaration,
@@ -49307,14 +49278,6 @@ function createTypeChecker(host) {
         return file.moduleName;
       }
       if (!file) {
-        if (context.tracker.trackReferencedAmbientModule) {
-          const ambientDecls = filter(symbol.declarations, isAmbientModule);
-          if (length(ambientDecls)) {
-            for (const decl of ambientDecls) {
-              context.tracker.trackReferencedAmbientModule(decl, symbol);
-            }
-          }
-        }
         if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
           return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
         }
@@ -49407,8 +49370,6 @@ function createTypeChecker(host) {
           }
         }
         const lit = factory.createLiteralTypeNode(factory.createStringLiteral(specifier));
-        if (context.tracker.trackExternalModuleSymbolOfImportTypeNode)
-          context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]);
         context.approximateLength += specifier.length + 10;
         if (!nonRootParts || isEntityName(nonRootParts)) {
           if (nonRootParts) {
@@ -49749,9 +49710,10 @@ function createTypeChecker(host) {
         introducesError = true;
         return { introducesError, node };
       }
+      const meaning = getMeaningOfEntityNameReference(node);
       const sym = resolveEntityName(
         leftmost,
-        -1 /* All */,
+        meaning,
         /*ignoreErrors*/
         true,
         /*dontResolveAlias*/
@@ -49761,7 +49723,7 @@ function createTypeChecker(host) {
         if (isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
-          -1 /* All */,
+          meaning,
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
@@ -49769,7 +49731,7 @@ function createTypeChecker(host) {
             introducesError = true;
           }
         } else {
-          context.tracker.trackSymbol(sym, context.enclosingDeclaration, -1 /* All */);
+          context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
           includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
         }
         if (isIdentifier(node)) {
@@ -49967,18 +49929,6 @@ function createTypeChecker(host) {
                 return factory.createStringLiteral(newName);
               }
             }
-          } else {
-            if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) {
-              const moduleSym = resolveExternalModuleNameWorker(
-                lit,
-                lit,
-                /*moduleNotFoundError*/
-                void 0
-              );
-              if (moduleSym) {
-                context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym);
-              }
-            }
           }
           return lit;
         }
@@ -57736,6 +57686,9 @@ function createTypeChecker(host) {
         } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && (t.types[0].flags & 65536 /* Null */ || t.types[1].flags & 65536 /* Null */)))) {
           removeFromEach(typeSet, 65536 /* Null */);
           result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+        } else if (typeSet.length >= 4) {
+          const middle = Math.floor(typeSet.length / 2);
+          result = getIntersectionType([getIntersectionType(typeSet.slice(0, middle)), getIntersectionType(typeSet.slice(middle))], aliasSymbol, aliasTypeArguments);
         } else {
           if (!checkCrossProductUnion(typeSet)) {
             return errorType;
@@ -70812,17 +70765,9 @@ function createTypeChecker(host) {
     );
     return result;
   }
-  function getSuggestionForNonexistentSymbol(location, outerName, meaning) {
-    const symbolResult = getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning);
-    return symbolResult && symbolName(symbolResult);
-  }
   function getSuggestedSymbolForNonexistentModule(name, targetModule) {
     return targetModule.exports && getSpellingSuggestionForName(idText(name), getExportsOfModuleAsArray(targetModule), 2623475 /* ModuleMember */);
   }
-  function getSuggestionForNonexistentExport(name, targetModule) {
-    const suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule);
-    return suggestion && symbolName(suggestion);
-  }
   function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) {
     function hasProp(name) {
       const prop = getPropertyOfObjectType(objectType, name);
@@ -80543,14 +80488,16 @@ function createTypeChecker(host) {
     if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
       nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
       let autoValue = 0;
+      let previous;
       for (const member of node.members) {
-        const value = computeMemberValue(member, autoValue);
+        const value = computeMemberValue(member, autoValue, previous);
         getNodeLinks(member).enumMemberValue = value;
         autoValue = typeof value === "number" ? value + 1 : void 0;
+        previous = member;
       }
     }
   }
-  function computeMemberValue(member, autoValue) {
+  function computeMemberValue(member, autoValue, previous) {
     if (isComputedNonLiteralName(member.name)) {
       error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
@@ -80565,11 +80512,17 @@ function createTypeChecker(host) {
     if (member.parent.flags & 33554432 /* Ambient */ && !isEnumConst(member.parent)) {
       return void 0;
     }
-    if (autoValue !== void 0) {
-      return autoValue;
+    if (autoValue === void 0) {
+      error(member.name, Diagnostics.Enum_member_must_have_initializer);
+      return void 0;
     }
-    error(member.name, Diagnostics.Enum_member_must_have_initializer);
-    return void 0;
+    if (getIsolatedModules(compilerOptions) && (previous == null ? void 0 : previous.initializer) && !isSyntacticallyNumericConstant(previous.initializer)) {
+      error(
+        member.name,
+        Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled
+      );
+    }
+    return autoValue;
   }
   function computeConstantValue(member) {
     const isConstEnum = isEnumConst(member.parent);
@@ -80581,6 +80534,12 @@ function createTypeChecker(host) {
           initializer,
           isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
         );
+      } else if (getIsolatedModules(compilerOptions) && typeof value === "string" && !isSyntacticallyString(initializer)) {
+        error(
+          initializer,
+          Diagnostics._0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled,
+          `${idText(member.parent.name)}.${getTextOfPropertyName(member.name)}`
+        );
       }
     } else if (isConstEnum) {
       error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
@@ -80591,6 +80550,18 @@ function createTypeChecker(host) {
     }
     return value;
   }
+  function isSyntacticallyNumericConstant(expr) {
+    expr = skipOuterExpressions(expr);
+    switch (expr.kind) {
+      case 224 /* PrefixUnaryExpression */:
+        return isSyntacticallyNumericConstant(expr.operand);
+      case 226 /* BinaryExpression */:
+        return isSyntacticallyNumericConstant(expr.left) && isSyntacticallyNumericConstant(expr.right);
+      case 9 /* NumericLiteral */:
+        return true;
+    }
+    return false;
+  }
   function evaluate(expr, location) {
     switch (expr.kind) {
       case 224 /* PrefixUnaryExpression */:
@@ -82620,23 +82591,6 @@ function createTypeChecker(host) {
     const isPropertyName2 = (isPropertyAccessExpression(parent) || isPropertyAssignment(parent)) && parent.name === node;
     return !isPropertyName2 && getReferencedValueSymbol(node) === argumentsSymbol;
   }
-  function moduleExportsSomeValue(moduleReferenceExpression) {
-    let moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
-    if (!moduleSymbol || isShorthandAmbientModuleSymbol(moduleSymbol)) {
-      return true;
-    }
-    const hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);
-    moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
-    const symbolLinks2 = getSymbolLinks(moduleSymbol);
-    if (symbolLinks2.exportsSomeValue === void 0) {
-      symbolLinks2.exportsSomeValue = hasExportAssignment ? !!(moduleSymbol.flags & 111551 /* Value */) : forEachEntry(getExportsOfModule(moduleSymbol), isValue);
-    }
-    return symbolLinks2.exportsSomeValue;
-    function isValue(s) {
-      s = resolveSymbol(s);
-      return s && !!(getSymbolFlags(s) & 111551 /* Value */);
-    }
-  }
   function isNameOfModuleOrEnumDeclaration(node) {
     return isModuleOrEnumDeclaration(node.parent) && node === node.parent.name;
   }
@@ -83213,20 +83167,6 @@ function createTypeChecker(host) {
     }
   }
   function createResolver() {
-    const resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
-    let fileToDirective;
-    if (resolvedTypeReferenceDirectives) {
-      fileToDirective = /* @__PURE__ */ new Map();
-      resolvedTypeReferenceDirectives.forEach(({ resolvedTypeReferenceDirective }, key, mode) => {
-        if (!(resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName)) {
-          return;
-        }
-        const file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName);
-        if (file) {
-          addReferencedFilesToTypeDirective(file, key, mode);
-        }
-      });
-    }
     return {
       getReferencedExportContainer,
       getReferencedImportDeclaration,
@@ -83266,14 +83206,11 @@ function createTypeChecker(host) {
       getReferencedValueDeclarations,
       getTypeReferenceSerializationKind,
       isOptionalParameter,
-      moduleExportsSomeValue,
       isArgumentsLocalBinding,
       getExternalModuleFileFromDeclaration: (nodeIn) => {
         const node = getParseTreeNode(nodeIn, hasPossibleExternalModuleReference);
         return node && getExternalModuleFileFromDeclaration(node);
       },
-      getTypeReferenceDirectivesForEntityName,
-      getTypeReferenceDirectivesForSymbol,
       isLiteralConstDeclaration,
       isLateBound: (nodeIn) => {
         const node = getParseTreeNode(nodeIn, isDeclaration);
@@ -83297,12 +83234,6 @@ function createTypeChecker(host) {
           getAccessor
         };
       },
-      getSymbolOfExternalModuleSpecifier: (moduleName) => resolveExternalModuleNameWorker(
-        moduleName,
-        moduleName,
-        /*moduleNotFoundError*/
-        void 0
-      ),
       isBindingCapturedByNode: (node, decl) => {
         const parseNode = getParseTreeNode(node);
         const parseDecl = getParseTreeNode(decl);
@@ -83317,16 +83248,7 @@ function createTypeChecker(host) {
         }
         return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
       },
-      isImportRequiredByAugmentation,
-      tryFindAmbientModule: (moduleReferenceExpression) => {
-        const node = getParseTreeNode(moduleReferenceExpression);
-        const moduleSpecifier = node && isStringLiteralLike(node) ? node.text : void 0;
-        return moduleSpecifier !== void 0 ? tryFindAmbientModule(
-          moduleSpecifier,
-          /*withAugmentations*/
-          true
-        ) : void 0;
-      }
+      isImportRequiredByAugmentation
     };
     function isImportRequiredByAugmentation(node) {
       const file = getSourceFileOfNode(node);
@@ -83353,84 +83275,6 @@ function createTypeChecker(host) {
       }
       return false;
     }
-    function isInHeritageClause(node) {
-      return node.parent && node.parent.kind === 233 /* ExpressionWithTypeArguments */ && node.parent.parent && node.parent.parent.kind === 298 /* HeritageClause */;
-    }
-    function getTypeReferenceDirectivesForEntityName(node) {
-      if (!fileToDirective) {
-        return void 0;
-      }
-      let meaning;
-      if (node.parent.kind === 167 /* ComputedPropertyName */) {
-        meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
-      } else {
-        meaning = 788968 /* Type */ | 1920 /* Namespace */;
-        if (node.kind === 80 /* Identifier */ && isInTypeQuery(node) || node.kind === 211 /* PropertyAccessExpression */ && !isInHeritageClause(node)) {
-          meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
-        }
-      }
-      const symbol = resolveEntityName(
-        node,
-        meaning,
-        /*ignoreErrors*/
-        true
-      );
-      return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : void 0;
-    }
-    function getTypeReferenceDirectivesForSymbol(symbol, meaning) {
-      if (!fileToDirective || !isSymbolFromTypeDeclarationFile(symbol)) {
-        return void 0;
-      }
-      let typeReferenceDirectives;
-      for (const decl of symbol.declarations) {
-        if (decl.symbol && decl.symbol.flags & meaning) {
-          const file = getSourceFileOfNode(decl);
-          const typeReferenceDirective = fileToDirective.get(file.path);
-          if (typeReferenceDirective) {
-            (typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective);
-          } else {
-            return void 0;
-          }
-        }
-      }
-      return typeReferenceDirectives;
-    }
-    function isSymbolFromTypeDeclarationFile(symbol) {
-      if (!symbol.declarations) {
-        return false;
-      }
-      let current = symbol;
-      while (true) {
-        const parent = getParentOfSymbol(current);
-        if (parent) {
-          current = parent;
-        } else {
-          break;
-        }
-      }
-      if (current.valueDeclaration && current.valueDeclaration.kind === 307 /* SourceFile */ && current.flags & 512 /* ValueModule */) {
-        return false;
-      }
-      for (const decl of symbol.declarations) {
-        const file = getSourceFileOfNode(decl);
-        if (fileToDirective.has(file.path)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    function addReferencedFilesToTypeDirective(file, key, mode) {
-      if (fileToDirective.has(file.path))
-        return;
-      fileToDirective.set(file.path, [key, mode]);
-      for (const { fileName } of file.referencedFiles) {
-        const resolvedFile = resolveTripleslashReference(fileName, file.fileName);
-        const referencedFile = host.getSourceFile(resolvedFile);
-        if (referencedFile) {
-          addReferencedFilesToTypeDirective(referencedFile, key, mode || file.impliedNodeFormat);
-        }
-      }
-    }
   }
   function getExternalModuleFileFromDeclaration(declaration) {
     const specifier = declaration.kind === 267 /* ModuleDeclaration */ ? tryCast(declaration.name, isStringLiteral) : getExternalModuleName(declaration);
@@ -85354,20 +85198,6 @@ var SymbolTrackerImpl = class _SymbolTrackerImpl {
       this.inner.reportTruncationError();
     }
   }
-  trackReferencedAmbientModule(decl, symbol) {
-    var _a;
-    if ((_a = this.inner) == null ? void 0 : _a.trackReferencedAmbientModule) {
-      this.onDiagnosticReported();
-      this.inner.trackReferencedAmbientModule(decl, symbol);
-    }
-  }
-  trackExternalModuleSymbolOfImportTypeNode(symbol) {
-    var _a;
-    if ((_a = this.inner) == null ? void 0 : _a.trackExternalModuleSymbolOfImportTypeNode) {
-      this.onDiagnosticReported();
-      this.inner.trackExternalModuleSymbolOfImportTypeNode(symbol);
-    }
-  }
   reportNonlocalAugmentation(containingFile, parentSymbol, augmentingSymbol) {
     var _a;
     if ((_a = this.inner) == null ? void 0 : _a.reportNonlocalAugmentation) {
@@ -108372,11 +108202,9 @@ function transformDeclarations(context) {
   let needsScopeFixMarker = false;
   let resultHasScopeMarker = false;
   let enclosingDeclaration;
-  let necessaryTypeReferences;
   let lateMarkedStatements;
   let lateStatementReplacementMap;
   let suppressNewDiagnosticContexts;
-  let exportedModulesFromDeclarationEmit;
   const { factory: factory2 } = context;
   const host = context.getEmitHost();
   const symbolTracker = {
@@ -108388,49 +108216,19 @@ function transformDeclarations(context) {
     reportLikelyUnsafeImportRequiredError,
     reportTruncationError,
     moduleResolverHost: host,
-    trackReferencedAmbientModule,
-    trackExternalModuleSymbolOfImportTypeNode,
     reportNonlocalAugmentation,
     reportNonSerializableProperty
   };
   let errorNameNode;
   let errorFallbackNode;
   let currentSourceFile;
-  let refs;
-  let libs2;
-  let emittedImports;
+  let rawReferencedFiles;
+  let rawTypeReferenceDirectives;
+  let rawLibReferenceDirectives;
   const resolver = context.getEmitResolver();
   const options = context.getCompilerOptions();
-  const { noResolve, stripInternal } = options;
+  const { stripInternal } = options;
   return transformRoot;
-  function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives) {
-    if (!typeReferenceDirectives) {
-      return;
-    }
-    necessaryTypeReferences = necessaryTypeReferences || /* @__PURE__ */ new Set();
-    for (const ref of typeReferenceDirectives) {
-      necessaryTypeReferences.add(ref);
-    }
-  }
-  function trackReferencedAmbientModule(node, symbol) {
-    const directives = resolver.getTypeReferenceDirectivesForSymbol(symbol, -1 /* All */);
-    if (length(directives)) {
-      return recordTypeReferenceDirectivesIfNecessary(directives);
-    }
-    const container = getSourceFileOfNode(node);
-    refs.set(getOriginalNodeId(container), container);
-  }
-  function trackReferencedAmbientModuleFromImport(node) {
-    const moduleSpecifier = tryGetModuleSpecifierFromDeclaration(node);
-    const symbol = moduleSpecifier && resolver.tryFindAmbientModule(moduleSpecifier);
-    if (symbol == null ? void 0 : symbol.declarations) {
-      for (const decl of symbol.declarations) {
-        if (isAmbientModule(decl) && getSourceFileOfNode(decl) !== currentSourceFile) {
-          trackReferencedAmbientModule(decl, symbol);
-        }
-      }
-    }
-  }
   function handleSymbolAccessibilityError(symbolAccessibilityResult) {
     if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
       if (symbolAccessibilityResult.aliasesToMakeVisible) {
@@ -108455,11 +108253,6 @@ function transformDeclarations(context) {
     }
     return false;
   }
-  function trackExternalModuleSymbolOfImportTypeNode(symbol) {
-    if (!isBundledEmit) {
-      (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);
-    }
-  }
   function trackSymbol(symbol, enclosingDeclaration2, meaning) {
     if (symbol.flags & 262144 /* TypeParameter */)
       return false;
@@ -108470,7 +108263,6 @@ function transformDeclarations(context) {
       /*shouldComputeAliasToMarkVisible*/
       true
     ));
-    recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
     return issuedDiagnostic;
   }
   function reportPrivateInBaseOfClassExpression(propertyName) {
@@ -108542,8 +108334,9 @@ function transformDeclarations(context) {
     }
     if (node.kind === 308 /* Bundle */) {
       isBundledEmit = true;
-      refs = /* @__PURE__ */ new Map();
-      libs2 = /* @__PURE__ */ new Map();
+      rawReferencedFiles = [];
+      rawTypeReferenceDirectives = [];
+      rawLibReferenceDirectives = [];
       let hasNoDefaultLib = false;
       const bundle = factory2.createBundle(
         map(node.sourceFiles, (sourceFile) => {
@@ -108558,8 +108351,7 @@ function transformDeclarations(context) {
           getSymbolAccessibilityDiagnostic = throwDiagnostic;
           needsScopeFixMarker = false;
           resultHasScopeMarker = false;
-          collectReferences(sourceFile, refs);
-          collectLibs(sourceFile, libs2);
+          collectFileReferences(sourceFile);
           if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {
             resultHasExternalModuleIndicator = false;
             needsDeclare = false;
@@ -108606,18 +108398,16 @@ function transformDeclarations(context) {
           );
         })
       );
-      bundle.syntheticFileReferences = [];
-      bundle.syntheticTypeReferences = getFileReferencesForUsedTypeReferences();
-      bundle.syntheticLibReferences = getLibReferences();
-      bundle.hasNoDefaultLib = hasNoDefaultLib;
       const outputFilePath2 = getDirectoryPath(normalizeSlashes(getOutputPathsFor(
         node,
         host,
         /*forceDtsPaths*/
         true
       ).declarationFilePath));
-      const referenceVisitor2 = mapReferencesIntoArray(bundle.syntheticFileReferences, outputFilePath2);
-      refs.forEach(referenceVisitor2);
+      bundle.syntheticFileReferences = getReferencedFiles(outputFilePath2);
+      bundle.syntheticTypeReferences = getTypeReferences();
+      bundle.syntheticLibReferences = getLibReferences();
+      bundle.hasNoDefaultLib = hasNoDefaultLib;
       return bundle;
     }
     needsDeclare = true;
@@ -108631,66 +108421,68 @@ function transformDeclarations(context) {
     suppressNewDiagnosticContexts = false;
     lateMarkedStatements = void 0;
     lateStatementReplacementMap = /* @__PURE__ */ new Map();
-    necessaryTypeReferences = void 0;
-    refs = collectReferences(currentSourceFile, /* @__PURE__ */ new Map());
-    libs2 = collectLibs(currentSourceFile, /* @__PURE__ */ new Map());
-    const references = [];
-    const outputFilePath = getDirectoryPath(normalizeSlashes(getOutputPathsFor(
-      node,
-      host,
-      /*forceDtsPaths*/
-      true
-    ).declarationFilePath));
-    const referenceVisitor = mapReferencesIntoArray(references, outputFilePath);
+    rawReferencedFiles = [];
+    rawTypeReferenceDirectives = [];
+    rawLibReferenceDirectives = [];
+    collectFileReferences(currentSourceFile);
     let combinedStatements;
     if (isSourceFileJS(currentSourceFile)) {
       combinedStatements = factory2.createNodeArray(transformDeclarationsForJS(node));
-      refs.forEach(referenceVisitor);
-      emittedImports = filter(combinedStatements, isAnyImportSyntax);
     } else {
       const statements = visitNodes2(node.statements, visitDeclarationStatements, isStatement);
       combinedStatements = setTextRange(factory2.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);
-      refs.forEach(referenceVisitor);
-      emittedImports = filter(combinedStatements, isAnyImportSyntax);
       if (isExternalModule(node) && (!resultHasExternalModuleIndicator || needsScopeFixMarker && !resultHasScopeMarker)) {
         combinedStatements = setTextRange(factory2.createNodeArray([...combinedStatements, createEmptyExports(factory2)]), combinedStatements);
       }
     }
+    const outputFilePath = getDirectoryPath(normalizeSlashes(getOutputPathsFor(
+      node,
+      host,
+      /*forceDtsPaths*/
+      true
+    ).declarationFilePath));
     return factory2.updateSourceFile(
       node,
       combinedStatements,
       /*isDeclarationFile*/
       true,
-      references,
-      getFileReferencesForUsedTypeReferences(),
+      getReferencedFiles(outputFilePath),
+      getTypeReferences(),
       node.hasNoDefaultLib,
       getLibReferences()
     );
-    function getLibReferences() {
-      return arrayFrom(libs2.keys(), (lib) => ({ fileName: lib, pos: -1, end: -1 }));
+    function collectFileReferences(sourceFile) {
+      rawReferencedFiles = concatenate(rawReferencedFiles, map(sourceFile.referencedFiles, (f) => [sourceFile, f]));
+      rawTypeReferenceDirectives = concatenate(rawTypeReferenceDirectives, sourceFile.typeReferenceDirectives);
+      rawLibReferenceDirectives = concatenate(rawLibReferenceDirectives, sourceFile.libReferenceDirectives);
     }
-    function getFileReferencesForUsedTypeReferences() {
-      return necessaryTypeReferences ? mapDefined(arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForSpecifierModeTuple) : [];
+    function copyFileReferenceAsSynthetic(ref) {
+      const newRef = { ...ref };
+      newRef.pos = -1;
+      newRef.end = -1;
+      return newRef;
     }
-    function getFileReferenceForSpecifierModeTuple([typeName, mode]) {
-      if (emittedImports) {
-        for (const importStatement of emittedImports) {
-          if (isImportEqualsDeclaration(importStatement) && isExternalModuleReference(importStatement.moduleReference)) {
-            const expr = importStatement.moduleReference.expression;
-            if (isStringLiteralLike(expr) && expr.text === typeName) {
-              return void 0;
-            }
-          } else if (isImportDeclaration(importStatement) && isStringLiteral(importStatement.moduleSpecifier) && importStatement.moduleSpecifier.text === typeName) {
-            return void 0;
-          }
-        }
-      }
-      return { fileName: typeName, pos: -1, end: -1, ...mode ? { resolutionMode: mode } : void 0 };
+    function getTypeReferences() {
+      return mapDefined(rawTypeReferenceDirectives, (ref) => {
+        if (!ref.preserve)
+          return void 0;
+        return copyFileReferenceAsSynthetic(ref);
+      });
     }
-    function mapReferencesIntoArray(references2, outputFilePath2) {
-      return (file) => {
-        if (exportedModulesFromDeclarationEmit == null ? void 0 : exportedModulesFromDeclarationEmit.includes(file.symbol)) {
-          return;
+    function getLibReferences() {
+      return mapDefined(rawLibReferenceDirectives, (ref) => {
+        if (!ref.preserve)
+          return void 0;
+        return copyFileReferenceAsSynthetic(ref);
+      });
+    }
+    function getReferencedFiles(outputFilePath2) {
+      return mapDefined(rawReferencedFiles, ([sourceFile, ref]) => {
+        if (!ref.preserve)
+          return void 0;
+        const file = host.getSourceFileFromReference(sourceFile, ref);
+        if (!file) {
+          return void 0;
         }
         let declFileName;
         if (file.isDeclarationFile) {
@@ -108706,61 +108498,22 @@ function transformDeclarations(context) {
           );
           declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName;
         }
-        if (declFileName) {
-          const specifier = getModuleSpecifier(
-            options,
-            currentSourceFile,
-            getNormalizedAbsolutePath(outputFilePath2, host.getCurrentDirectory()),
-            getNormalizedAbsolutePath(declFileName, host.getCurrentDirectory()),
-            host
-          );
-          if (!pathIsRelative(specifier)) {
-            recordTypeReferenceDirectivesIfNecessary([[
-              specifier,
-              /*mode*/
-              void 0
-            ]]);
-            return;
-          }
-          let fileName = getRelativePathToDirectoryOrUrl(
-            outputFilePath2,
-            declFileName,
-            host.getCurrentDirectory(),
-            host.getCanonicalFileName,
-            /*isAbsolutePathAnUrl*/
-            false
-          );
-          if (startsWith(fileName, "./") && hasExtension(fileName)) {
-            fileName = fileName.substring(2);
-          }
-          if (startsWith(fileName, "node_modules/") || pathContainsNodeModules(fileName)) {
-            return;
-          }
-          references2.push({ pos: -1, end: -1, fileName });
-        }
-      };
+        if (!declFileName)
+          return void 0;
+        const fileName = getRelativePathToDirectoryOrUrl(
+          outputFilePath2,
+          declFileName,
+          host.getCurrentDirectory(),
+          host.getCanonicalFileName,
+          /*isAbsolutePathAnUrl*/
+          false
+        );
+        const newRef = copyFileReferenceAsSynthetic(ref);
+        newRef.fileName = fileName;
+        return newRef;
+      });
     }
   }
-  function collectReferences(sourceFile, ret) {
-    if (noResolve || isSourceFileJS(sourceFile))
-      return ret;
-    forEach(sourceFile.referencedFiles, (f) => {
-      const elem = host.getSourceFileFromReference(sourceFile, f);
-      if (elem) {
-        ret.set(getOriginalNodeId(elem), elem);
-      }
-    });
-    return ret;
-  }
-  function collectLibs(sourceFile, ret) {
-    forEach(sourceFile.libReferenceDirectives, (ref) => {
-      const lib = host.getLibFileFromReference(ref);
-      if (lib) {
-        ret.set(toFileNameLowerCase(ref.fileName), true);
-      }
-    });
-    return ret;
-  }
   function filterBindingPatternInitializers(name) {
     if (name.kind === 80 /* Identifier */) {
       return name;
@@ -108959,7 +108712,6 @@ function transformDeclarations(context) {
   function checkEntityNameVisibility(entityName, enclosingDeclaration2) {
     const visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration2);
     handleSymbolAccessibilityError(visibilityResult);
-    recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName));
   }
   function preserveJsDoc(updated, original) {
     if (hasJSDocNodes(updated) && hasJSDocNodes(original)) {
@@ -108977,11 +108729,6 @@ function transformDeclarations(context) {
         if (newName) {
           return factory2.createStringLiteral(newName);
         }
-      } else {
-        const symbol = resolver.getSymbolOfExternalModuleSpecifier(input);
-        if (symbol) {
-          (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);
-        }
       }
     }
     return input;
@@ -109374,7 +109121,6 @@ function transformDeclarations(context) {
         case 205 /* ImportType */: {
           if (!isLiteralImportTypeNode(input))
             return cleanup(input);
-          trackReferencedAmbientModuleFromImport(input);
           return cleanup(factory2.updateImportTypeNode(
             input,
             factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)),
@@ -109426,7 +109172,6 @@ function transformDeclarations(context) {
           resultHasExternalModuleIndicator = true;
         }
         resultHasScopeMarker = true;
-        trackReferencedAmbientModuleFromImport(input);
         return factory2.updateExportDeclaration(
           input,
           input.modifiers,
@@ -109501,18 +109246,10 @@ function transformDeclarations(context) {
       return;
     switch (input.kind) {
       case 271 /* ImportEqualsDeclaration */: {
-        const transformed = transformImportEqualsDeclaration(input);
-        if (transformed) {
-          trackReferencedAmbientModuleFromImport(input);
-        }
-        return transformed;
+        return transformImportEqualsDeclaration(input);
       }
       case 272 /* ImportDeclaration */: {
-        const transformed = transformImportDeclaration(input);
-        if (transformed) {
-          trackReferencedAmbientModuleFromImport(input);
-        }
-        return transformed;
+        return transformImportDeclaration(input);
       }
     }
     if (isDeclaration(input) && isDeclarationAndNotVisible(input))
@@ -111071,20 +110808,15 @@ var notImplementedResolver = {
   getReferencedValueDeclarations: notImplemented,
   getTypeReferenceSerializationKind: notImplemented,
   isOptionalParameter: notImplemented,
-  moduleExportsSomeValue: notImplemented,
   isArgumentsLocalBinding: notImplemented,
   getExternalModuleFileFromDeclaration: notImplemented,
-  getTypeReferenceDirectivesForEntityName: notImplemented,
-  getTypeReferenceDirectivesForSymbol: notImplemented,
   isLiteralConstDeclaration: notImplemented,
   getJsxFactoryEntity: notImplemented,
   getJsxFragmentFactoryEntity: notImplemented,
   getAllAccessorDeclarations: notImplemented,
-  getSymbolOfExternalModuleSpecifier: notImplemented,
   isBindingCapturedByNode: notImplemented,
   getDeclarationStatementsForSourceFile: notImplemented,
-  isImportRequiredByAugmentation: notImplemented,
-  tryFindAmbientModule: notImplemented
+  isImportRequiredByAugmentation: notImplemented
 };
 var createPrinterWithDefaults = /* @__PURE__ */ memoize(() => createPrinter({}));
 var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true }));
@@ -113839,19 +113571,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         writeLine();
       }
     }
-    for (const directive of files) {
-      writeComment(`/// <reference path="${directive.fileName}" />`);
-      writeLine();
-    }
-    for (const directive of types) {
-      const resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile == null ? void 0 : currentSourceFile.impliedNodeFormat) ? `resolution-mode="${directive.resolutionMode === 99 /* ESNext */ ? "import" : "require"}"` : "";
-      writeComment(`/// <reference types="${directive.fileName}" ${resolutionMode}/>`);
-      writeLine();
-    }
-    for (const directive of libs2) {
-      writeComment(`/// <reference lib="${directive.fileName}" />`);
-      writeLine();
+    function writeDirectives(kind, directives) {
+      for (const directive of directives) {
+        const resolutionMode = directive.resolutionMode ? `resolution-mode="${directive.resolutionMode === 99 /* ESNext */ ? "import" : "require"}" ` : "";
+        const preserve = directive.preserve ? `preserve="true" ` : "";
+        writeComment(`/// <reference ${kind}="${directive.fileName}" ${resolutionMode}${preserve}/>`);
+        writeLine();
+      }
     }
+    writeDirectives("path", files);
+    writeDirectives("types", types);
+    writeDirectives("lib", libs2);
   }
   function emitSourceFileWorker(node) {
     const statements = node.statements;
@@ -117688,7 +117418,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       getSourceFile: program.getSourceFile,
       getSourceFileByPath: program.getSourceFileByPath,
       getSourceFiles: program.getSourceFiles,
-      getLibFileFromReference: program.getLibFileFromReference,
       isSourceFileFromExternalLibrary,
       getResolvedProjectReferenceToRedirect,
       getProjectReferenceRedirect,