typescript 5.5.0-dev.20240319 → 5.5.0-dev.20240321

package/lib/typescript.js

@@ -2326,7 +2326,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240319`;
+var version = `${versionMajorMinor}.0-dev.20240321`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7393,7 +7393,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 */
   },
@@ -11347,7 +11348,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
@@ -15657,6 +15660,9 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       es2015: [
         "from",
         "of"
+      ],
+      esnext: [
+        "fromAsync"
       ]
     })),
     ObjectConstructor: new Map(Object.entries({
@@ -36962,7 +36968,7 @@ var Parser;
               80 /* Identifier */,
               /*reportAtCurrentPosition*/
               false
-            ) : parseIdentifier()), pos);
+            ) : parseIdentifierName()), pos);
           }
           while (token() === 81 /* PrivateIdentifier */) {
             reScanHashToken();
@@ -37910,16 +37916,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);
           }
@@ -38177,6 +38184,7 @@ var libEntries = [
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
   ["esnext.object", "lib.esnext.object.d.ts"],
+  ["esnext.array", "lib.esnext.array.d.ts"],
   ["esnext.regexp", "lib.esnext.regexp.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
@@ -51869,13 +51877,6 @@ function createTypeChecker(host) {
     });
   }
   function getSymbolIfSameReference(s1, s2) {
-    var _a, _b;
-    if (s1.flags & 524288 /* TypeAlias */ && ((_a = s2.declarations) == null ? void 0 : _a.find(isTypeAlias))) {
-      s2 = getDeclaredTypeOfTypeAlias(s2).aliasSymbol || s2;
-    }
-    if (s2.flags & 524288 /* TypeAlias */ && ((_b = s1.declarations) == null ? void 0 : _b.find(isTypeAlias))) {
-      s1 = getDeclaredTypeOfTypeAlias(s1).aliasSymbol || s1;
-    }
     if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
       return s1;
     }
@@ -54038,14 +54039,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);
         }
@@ -54138,8 +54131,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) {
@@ -54698,18 +54689,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;
         }
@@ -85274,19 +85253,21 @@ 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)) {
       error2(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
       const text = getTextOfPropertyName(member.name);
-      if (isNumericLiteralName(text)) {
+      if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
         error2(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
       }
     }
@@ -85296,11 +85277,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) {
+      error2(member.name, Diagnostics.Enum_member_must_have_initializer);
+      return void 0;
     }
-    error2(member.name, Diagnostics.Enum_member_must_have_initializer);
-    return void 0;
+    if (getIsolatedModules(compilerOptions) && (previous == null ? void 0 : previous.initializer) && !isSyntacticallyNumericConstant(previous.initializer)) {
+      error2(
+        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);
@@ -85312,6 +85299,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)) {
+        error2(
+          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) {
       error2(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
@@ -85322,6 +85315,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 */:
@@ -87351,23 +87356,6 @@ function createTypeChecker(host) {
     const isPropertyName2 = (isPropertyAccessExpression(parent2) || isPropertyAssignment(parent2)) && parent2.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;
   }
@@ -87944,20 +87932,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,
@@ -87997,14 +87971,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);
@@ -88028,12 +87999,6 @@ function createTypeChecker(host) {
           getAccessor
         };
       },
-      getSymbolOfExternalModuleSpecifier: (moduleName) => resolveExternalModuleNameWorker(
-        moduleName,
-        moduleName,
-        /*moduleNotFoundError*/
-        void 0
-      ),
       isBindingCapturedByNode: (node, decl) => {
         const parseNode = getParseTreeNode(node);
         const parseDecl = getParseTreeNode(decl);
@@ -88048,16 +88013,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);
@@ -88084,84 +88040,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 parent2 = getParentOfSymbol(current);
-        if (parent2) {
-          current = parent2;
-        } 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);
@@ -90085,20 +89963,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) {
@@ -113290,11 +113154,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 = {
@@ -113306,49 +113168,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) {
@@ -113373,11 +113205,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;
@@ -113388,7 +113215,6 @@ function transformDeclarations(context) {
       /*shouldComputeAliasToMarkVisible*/
       true
     ));
-    recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
     return issuedDiagnostic;
   }
   function reportPrivateInBaseOfClassExpression(propertyName) {
@@ -113460,8 +113286,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) => {
@@ -113476,8 +113303,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;
@@ -113524,18 +113350,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;
@@ -113549,66 +113373,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) {
@@ -113624,61 +113450,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;
@@ -113877,7 +113664,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)) {
@@ -113895,11 +113681,6 @@ function transformDeclarations(context) {
         if (newName) {
           return factory2.createStringLiteral(newName);
         }
-      } else {
-        const symbol = resolver.getSymbolOfExternalModuleSpecifier(input);
-        if (symbol) {
-          (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);
-        }
       }
     }
     return input;
@@ -114292,7 +114073,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)),
@@ -114344,7 +114124,6 @@ function transformDeclarations(context) {
           resultHasExternalModuleIndicator = true;
         }
         resultHasScopeMarker = true;
-        trackReferencedAmbientModuleFromImport(input);
         return factory2.updateExportDeclaration(
           input,
           input.modifiers,
@@ -114419,18 +114198,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))
@@ -116000,20 +115771,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 }));
@@ -118768,19 +118534,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 preserve = directive.preserve ? `preserve="true" ` : "";
+        const resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile == null ? void 0 : currentSourceFile.impliedNodeFormat) ? `resolution-mode="${directive.resolutionMode === 99 /* ESNext */ ? "import" : "require"}" ` : "";
+        writeComment(`/// <reference ${kind}="${directive.fileName}" ${resolutionMode}${preserve}/>`);
+        writeLine();
+      }
     }
+    writeDirectives("path", files);
+    writeDirectives("types", types);
+    writeDirectives("lib", libs2);
   }
   function emitSourceFileWorker(node) {
     const statements = node.statements;
@@ -122660,7 +122424,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       getSourceFile: program.getSourceFile,
       getSourceFileByPath: program.getSourceFileByPath,
       getSourceFiles: program.getSourceFiles,
-      getLibFileFromReference: program.getLibFileFromReference,
       isSourceFileFromExternalLibrary,
       getResolvedProjectReferenceToRedirect,
       getProjectReferenceRedirect,
@@ -133032,9 +132795,13 @@ function createTextSpanFromNode(node, sourceFile, endNode2) {
   return createTextSpanFromBounds(node.getStart(sourceFile), (endNode2 || node).getEnd());
 }
 function createTextSpanFromStringLiteralLikeContent(node) {
-  if (node.isUnterminated)
-    return void 0;
-  return createTextSpanFromBounds(node.getStart() + 1, node.getEnd() - 1);
+  let replacementEnd = node.getEnd() - 1;
+  if (node.isUnterminated) {
+    if (node.getStart() === replacementEnd)
+      return void 0;
+    replacementEnd = node.getEnd();
+  }
+  return createTextSpanFromBounds(node.getStart() + 1, replacementEnd);
 }
 function createTextRangeFromNode(node, sourceFile) {
   return createRange(node.getStart(sourceFile), node.end);
@@ -140057,7 +139824,9 @@ function updateImportsInOtherFiles(changes, program, host, oldFile, movedSymbols
           return !!symbol && movedSymbols.has(symbol);
         };
         deleteUnusedImports(sourceFile, importNode, changes, shouldMove);
-        const pathToTargetFileWithExtension = resolvePath(getDirectoryPath(oldFile.path), targetFileName);
+        const pathToTargetFileWithExtension = resolvePath(getDirectoryPath(getNormalizedAbsolutePath(oldFile.fileName, program.getCurrentDirectory())), targetFileName);
+        if (getStringComparer(!program.useCaseSensitiveFileNames())(pathToTargetFileWithExtension, sourceFile.fileName) === 0 /* EqualTo */)
+          return;
         const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
         const newImportDeclaration = filterImport(importNode, makeStringLiteral(newModuleSpecifier, quotePreference), shouldMove);
         if (newImportDeclaration)
@@ -140192,7 +139961,7 @@ function createOldFileImportsFromTargetFile(sourceFile, targetFileNeedExport, ta
   return makeImportOrRequire(sourceFile, defaultImport, imports, targetFileNameWithExtension, program, host, useEs6Imports, quotePreference);
 }
 function makeImportOrRequire(sourceFile, defaultImport, imports, targetFileNameWithExtension, program, host, useEs6Imports, quotePreference) {
-  const pathToTargetFile = resolvePath(getDirectoryPath(sourceFile.path), targetFileNameWithExtension);
+  const pathToTargetFile = resolvePath(getDirectoryPath(getNormalizedAbsolutePath(sourceFile.fileName, program.getCurrentDirectory())), targetFileNameWithExtension);
   const pathToTargetFileWithCorrectExtension = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFile, createModuleSpecifierResolutionHost(program, host));
   if (useEs6Imports) {
     const specifiers = imports.map((i) => factory.createImportSpecifier(