typescript 5.6.0-dev.20240808 → 5.6.0-dev.20240810

package/lib/typescript.js

@@ -96,6 +96,7 @@ __export(typescript_exports, {
   InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
+  InternalNodeBuilderFlags: () => InternalNodeBuilderFlags,
   InternalSymbolName: () => InternalSymbolName,
   IntersectionFlags: () => IntersectionFlags,
   InvalidatedProjectKind: () => InvalidatedProjectKind,
@@ -1083,6 +1084,7 @@ __export(typescript_exports, {
   hasEffectiveModifiers: () => hasEffectiveModifiers,
   hasEffectiveReadonlyModifier: () => hasEffectiveReadonlyModifier,
   hasExtension: () => hasExtension,
+  hasImplementationTSFileExtension: () => hasImplementationTSFileExtension,
   hasIndexSignature: () => hasIndexSignature,
   hasInferredType: () => hasInferredType,
   hasInitializer: () => hasInitializer,
@@ -2260,7 +2262,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240808`;
+var version = `${versionMajorMinor}.0-dev.20240810`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6168,17 +6170,21 @@ var NodeBuilderFlags = /* @__PURE__ */ ((NodeBuilderFlags2) => {
   NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyTuple"] = 524288] = "AllowEmptyTuple";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyIndexInfoType"] = 2097152] = "AllowEmptyIndexInfoType";
-  NodeBuilderFlags2[NodeBuilderFlags2["WriteComputedProps"] = 1073741824] = "WriteComputedProps";
-  NodeBuilderFlags2[NodeBuilderFlags2["NoSyntacticPrinter"] = -2147483648] = "NoSyntacticPrinter";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths";
-  NodeBuilderFlags2[NodeBuilderFlags2["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain";
-  NodeBuilderFlags2[NodeBuilderFlags2["AllowUnresolvedNames"] = 1] = "AllowUnresolvedNames";
   NodeBuilderFlags2[NodeBuilderFlags2["IgnoreErrors"] = 70221824] = "IgnoreErrors";
   NodeBuilderFlags2[NodeBuilderFlags2["InObjectTypeLiteral"] = 4194304] = "InObjectTypeLiteral";
   NodeBuilderFlags2[NodeBuilderFlags2["InTypeAlias"] = 8388608] = "InTypeAlias";
   NodeBuilderFlags2[NodeBuilderFlags2["InInitialEntityName"] = 16777216] = "InInitialEntityName";
   return NodeBuilderFlags2;
 })(NodeBuilderFlags || {});
+var InternalNodeBuilderFlags = /* @__PURE__ */ ((InternalNodeBuilderFlags2) => {
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["None"] = 0] = "None";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["WriteComputedProps"] = 1] = "WriteComputedProps";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["NoSyntacticPrinter"] = 2] = "NoSyntacticPrinter";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["DoNotIncludeSymbolChain"] = 4] = "DoNotIncludeSymbolChain";
+  InternalNodeBuilderFlags2[InternalNodeBuilderFlags2["AllowUnresolvedNames"] = 8] = "AllowUnresolvedNames";
+  return InternalNodeBuilderFlags2;
+})(InternalNodeBuilderFlags || {});
 var TypeFormatFlags = /* @__PURE__ */ ((TypeFormatFlags2) => {
   TypeFormatFlags2[TypeFormatFlags2["None"] = 0] = "None";
   TypeFormatFlags2[TypeFormatFlags2["NoTruncation"] = 1] = "NoTruncation";
@@ -22233,6 +22239,9 @@ function hasJSFileExtension(fileName) {
 function hasTSFileExtension(fileName) {
   return some(supportedTSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
 }
+function hasImplementationTSFileExtension(fileName) {
+  return some(supportedTSImplementationExtensions, (extension) => fileExtensionIs(fileName, extension)) && !isDeclarationFileName(fileName);
+}
 var ModuleSpecifierEnding = /* @__PURE__ */ ((ModuleSpecifierEnding2) => {
   ModuleSpecifierEnding2[ModuleSpecifierEnding2["Minimal"] = 0] = "Minimal";
   ModuleSpecifierEnding2[ModuleSpecifierEnding2["Index"] = 1] = "Index";
@@ -25386,7 +25395,11 @@ function createNodeFactory(flags, baseFactory2) {
     node.modifiers = asNodeArray(modifiers);
     node.parameters = createNodeArray(parameters);
     node.body = body;
-    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | 1024 /* ContainsES2015 */;
+    if (!node.body) {
+      node.transformFlags = 1 /* ContainsTypeScript */;
+    } else {
+      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | 1024 /* ContainsES2015 */;
+    }
     node.typeParameters = void 0;
     node.type = void 0;
     node.typeArguments = void 0;
@@ -29555,7 +29568,7 @@ var asyncGeneratorHelper = {
         var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
             if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
             var g = generator.apply(thisArg, _arguments || []), i, q = [];
-            return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+            return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
             function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
             function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
             function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
@@ -29737,8 +29750,8 @@ var generatorHelper = {
   priority: 6,
   text: `
             var __generator = (this && this.__generator) || function (thisArg, body) {
-                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-                return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+                return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
                 function verb(n) { return function (v) { return step([n, v]); }; }
                 function step(op) {
                     if (f) throw new TypeError("Generator is already executing.");
@@ -48877,6 +48890,28 @@ __export(ts_moduleSpecifiers_exports, {
 });
 
 // src/compiler/moduleSpecifiers.ts
+var stringToRegex = memoizeOne((pattern) => {
+  try {
+    let slash = pattern.indexOf("/");
+    if (slash !== 0) {
+      return new RegExp(pattern);
+    }
+    const lastSlash = pattern.lastIndexOf("/");
+    if (slash === lastSlash) {
+      return new RegExp(pattern);
+    }
+    while ((slash = pattern.indexOf("/", slash + 1)) !== lastSlash) {
+      if (pattern[slash - 1] !== "\\") {
+        return new RegExp(pattern);
+      }
+    }
+    const flags = pattern.substring(lastSlash + 1).replace(/[^iu]/g, "");
+    pattern = pattern.substring(1, lastSlash);
+    return new RegExp(pattern, flags);
+  } catch {
+    return void 0;
+  }
+});
 var RelativePreference = /* @__PURE__ */ ((RelativePreference2) => {
   RelativePreference2[RelativePreference2["Relative"] = 0] = "Relative";
   RelativePreference2[RelativePreference2["NonRelative"] = 1] = "NonRelative";
@@ -48884,9 +48919,10 @@ var RelativePreference = /* @__PURE__ */ ((RelativePreference2) => {
   RelativePreference2[RelativePreference2["ExternalNonRelative"] = 3] = "ExternalNonRelative";
   return RelativePreference2;
 })(RelativePreference || {});
-function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }, host, compilerOptions, importingSourceFile, oldImportSpecifier) {
+function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding, autoImportSpecifierExcludeRegexes }, host, compilerOptions, importingSourceFile, oldImportSpecifier) {
   const filePreferredEnding = getPreferredEnding();
   return {
+    excludeRegexes: autoImportSpecifierExcludeRegexes,
     relativePreference: oldImportSpecifier !== void 0 ? isExternalModuleNameRelative(oldImportSpecifier) ? 0 /* Relative */ : 1 /* NonRelative */ : importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : 2 /* Shortest */,
     getAllowedEndingsInPreferredOrder: (syntaxImpliedNodeFormat) => {
       const impliedNodeFormat = getDefaultResolutionModeForFile(importingSourceFile, host, compilerOptions);
@@ -49003,7 +49039,13 @@ function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSo
 function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
   let computedWithoutCache = false;
   const ambient = tryGetModuleNameFromAmbientModule(moduleSymbol, checker);
-  if (ambient) return { kind: "ambient", moduleSpecifiers: [ambient], computedWithoutCache };
+  if (ambient) {
+    return {
+      kind: "ambient",
+      moduleSpecifiers: !(forAutoImport && isExcludedByRegex(ambient, userPreferences.autoImportSpecifierExcludeRegexes)) ? [ambient] : emptyArray,
+      computedWithoutCache
+    };
+  }
   let [kind, specifiers, moduleSourceFile, modulePaths, cache] = tryGetModuleSpecifiersFromCacheWorker(
     moduleSymbol,
     importingSourceFile,
@@ -49075,9 +49117,11 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
       void 0,
       options.overrideImportMode
     ) : void 0;
-    nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
-    if (specifier && modulePath.isRedirect) {
-      return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true };
+    if (specifier && !(forAutoImport && isExcludedByRegex(specifier, preferences.excludeRegexes))) {
+      nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
+      if (modulePath.isRedirect) {
+        return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true };
+      }
     }
     if (!specifier) {
       const local = getLocalModuleSpecifier(
@@ -49090,7 +49134,7 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
         /*pathsOnly*/
         modulePath.isRedirect
       );
-      if (!local) {
+      if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) {
         continue;
       }
       if (modulePath.isRedirect) {
@@ -49106,7 +49150,13 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
       }
     }
   }
-  return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? { kind: "paths", moduleSpecifiers: pathsSpecifiers, computedWithoutCache: true } : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? { kind: "redirect", moduleSpecifiers: redirectPathsSpecifiers, computedWithoutCache: true } : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true } : { kind: "relative", moduleSpecifiers: Debug.checkDefined(relativeSpecifiers), computedWithoutCache: true };
+  return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? { kind: "paths", moduleSpecifiers: pathsSpecifiers, computedWithoutCache: true } : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? { kind: "redirect", moduleSpecifiers: redirectPathsSpecifiers, computedWithoutCache: true } : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true } : { kind: "relative", moduleSpecifiers: relativeSpecifiers ?? emptyArray, computedWithoutCache: true };
+}
+function isExcludedByRegex(moduleSpecifier, excludeRegexes) {
+  return some(excludeRegexes, (pattern) => {
+    var _a;
+    return !!((_a = stringToRegex(pattern)) == null ? void 0 : _a.test(moduleSpecifier));
+  });
 }
 function getInfo(importingSourceFileName, host) {
   importingSourceFileName = getNormalizedAbsolutePath(importingSourceFileName, host.getCurrentDirectory());
@@ -49119,7 +49169,7 @@ function getInfo(importingSourceFileName, host) {
     canonicalSourceDirectory: getCanonicalFileName(sourceDirectory)
   };
 }
-function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { getAllowedEndingsInPreferredOrder: getAllowedEndingsInPrefererredOrder, relativePreference }, pathsOnly) {
+function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { getAllowedEndingsInPreferredOrder: getAllowedEndingsInPrefererredOrder, relativePreference, excludeRegexes }, pathsOnly) {
   const { baseUrl, paths, rootDirs } = compilerOptions;
   if (pathsOnly && !paths) {
     return void 0;
@@ -49135,7 +49185,14 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   if (!relativeToBaseUrl) {
     return pathsOnly ? void 0 : relativePath;
   }
-  const fromPackageJsonImports = pathsOnly ? void 0 : tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, compilerOptions, host, importMode);
+  const fromPackageJsonImports = pathsOnly ? void 0 : tryGetModuleNameFromPackageJsonImports(
+    moduleFileName,
+    sourceDirectory,
+    compilerOptions,
+    host,
+    importMode,
+    prefersTsExtension(allowedEndings)
+  );
   const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) : void 0;
   if (pathsOnly) {
     return fromPaths;
@@ -49144,6 +49201,14 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   if (!maybeNonRelative) {
     return relativePath;
   }
+  const relativeIsExcluded = isExcludedByRegex(relativePath, excludeRegexes);
+  const nonRelativeIsExcluded = isExcludedByRegex(maybeNonRelative, excludeRegexes);
+  if (!relativeIsExcluded && nonRelativeIsExcluded) {
+    return relativePath;
+  }
+  if (relativeIsExcluded && !nonRelativeIsExcluded) {
+    return maybeNonRelative;
+  }
   if (relativePreference === 1 /* NonRelative */ && !pathIsRelative(maybeNonRelative)) {
     return maybeNonRelative;
   }
@@ -49383,7 +49448,7 @@ function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, hos
     return ending !== 0 /* Minimal */ || value === processEnding(relativeToBaseUrl, [ending], compilerOptions, host);
   }
 }
-function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, exports2, conditions, mode, isImports) {
+function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, exports2, conditions, mode, isImports, preferTsExtension) {
   if (typeof exports2 === "string") {
     const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
     const getCommonSourceDirectory2 = () => host.getCommonSourceDirectory();
@@ -49395,6 +49460,7 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
       void 0
     );
     const extensionSwappedTarget = hasTSFileExtension(targetFilePath) ? removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : void 0;
+    const canTryTsExtension = preferTsExtension && hasImplementationTSFileExtension(targetFilePath);
     switch (mode) {
       case 0 /* Exact */:
         if (extensionSwappedTarget && comparePaths(extensionSwappedTarget, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || comparePaths(targetFilePath, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || outputFile && comparePaths(outputFile, pathOrPattern, ignoreCase) === 0 /* EqualTo */ || declarationFile && comparePaths(declarationFile, pathOrPattern, ignoreCase) === 0 /* EqualTo */) {
@@ -49402,6 +49468,19 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
         }
         break;
       case 1 /* Directory */:
+        if (canTryTsExtension && containsPath(targetFilePath, pathOrPattern, ignoreCase)) {
+          const fragment = getRelativePathFromDirectory(
+            pathOrPattern,
+            targetFilePath,
+            /*ignoreCase*/
+            false
+          );
+          return { moduleFileToTry: getNormalizedAbsolutePath(
+            combinePaths(combinePaths(packageName, exports2), fragment),
+            /*currentDirectory*/
+            void 0
+          ) };
+        }
         if (extensionSwappedTarget && containsPath(pathOrPattern, extensionSwappedTarget, ignoreCase)) {
           const fragment = getRelativePathFromDirectory(
             pathOrPattern,
@@ -49415,7 +49494,7 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
             void 0
           ) };
         }
-        if (containsPath(pathOrPattern, targetFilePath, ignoreCase)) {
+        if (!canTryTsExtension && containsPath(pathOrPattern, targetFilePath, ignoreCase)) {
           const fragment = getRelativePathFromDirectory(
             pathOrPattern,
             targetFilePath,
@@ -49438,12 +49517,12 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
           return { moduleFileToTry: combinePaths(packageName, fragment) };
         }
         if (declarationFile && containsPath(pathOrPattern, declarationFile, ignoreCase)) {
-          const fragment = getRelativePathFromDirectory(
+          const fragment = changeFullExtension(getRelativePathFromDirectory(
             pathOrPattern,
             declarationFile,
             /*ignoreCase*/
             false
-          );
+          ), getJSExtensionForFile(declarationFile, options));
           return { moduleFileToTry: combinePaths(packageName, fragment) };
         }
         break;
@@ -49451,11 +49530,15 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
         const starPos = pathOrPattern.indexOf("*");
         const leadingSlice = pathOrPattern.slice(0, starPos);
         const trailingSlice = pathOrPattern.slice(starPos + 1);
+        if (canTryTsExtension && startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
+          const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
+          return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
+        }
         if (extensionSwappedTarget && startsWith(extensionSwappedTarget, leadingSlice, ignoreCase) && endsWith(extensionSwappedTarget, trailingSlice, ignoreCase)) {
           const starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
           return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
         }
-        if (startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
+        if (!canTryTsExtension && startsWith(targetFilePath, leadingSlice, ignoreCase) && endsWith(targetFilePath, trailingSlice, ignoreCase)) {
           const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
           return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
         }
@@ -49465,17 +49548,19 @@ function tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, pac
         }
         if (declarationFile && startsWith(declarationFile, leadingSlice, ignoreCase) && endsWith(declarationFile, trailingSlice, ignoreCase)) {
           const starReplacement = declarationFile.slice(leadingSlice.length, declarationFile.length - trailingSlice.length);
-          return { moduleFileToTry: replaceFirstStar(packageName, starReplacement) };
+          const substituted = replaceFirstStar(packageName, starReplacement);
+          const jsExtension = tryGetJSExtensionForFile(declarationFile, options);
+          return jsExtension ? { moduleFileToTry: changeFullExtension(substituted, jsExtension) } : void 0;
         }
         break;
     }
   } else if (Array.isArray(exports2)) {
-    return forEach(exports2, (e) => tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, e, conditions, mode, isImports));
+    return forEach(exports2, (e) => tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, e, conditions, mode, isImports, preferTsExtension));
   } else if (typeof exports2 === "object" && exports2 !== null) {
     for (const key of getOwnKeys(exports2)) {
       if (key === "default" || conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(conditions, key)) {
         const subTarget = exports2[key];
-        const result = tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode, isImports);
+        const result = tryGetModuleNameFromExportsOrImports(options, host, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode, isImports, preferTsExtension);
         if (result) {
           return result;
         }
@@ -49503,6 +49588,8 @@ function tryGetModuleNameFromExports(options, host, targetFilePath, packageDirec
         conditions,
         mode,
         /*isImports*/
+        false,
+        /*preferTsExtension*/
         false
       );
     });
@@ -49517,10 +49604,12 @@ function tryGetModuleNameFromExports(options, host, targetFilePath, packageDirec
     conditions,
     0 /* Exact */,
     /*isImports*/
+    false,
+    /*preferTsExtension*/
     false
   );
 }
-function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, options, host, importMode) {
+function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory, options, host, importMode, preferTsExtension) {
   var _a, _b, _c;
   if (!host.readFile || !getResolvePackageJsonImports(options)) {
     return void 0;
@@ -49553,7 +49642,8 @@ function tryGetModuleNameFromPackageJsonImports(moduleFileName, sourceDirectory,
       conditions,
       mode,
       /*isImports*/
-      true
+      true,
+      preferTsExtension
     );
   })) == null ? void 0 : _c.moduleFileToTry;
 }
@@ -49635,7 +49725,15 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
         const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
         const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2);
         const conditions = getConditions(options, importMode);
-        const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0;
+        const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(
+          options,
+          host,
+          path,
+          packageRootPath,
+          packageName2,
+          packageJsonContent.exports,
+          conditions
+        ) : void 0;
         if (fromExports) {
           return { ...fromExports, verbatimFromExports: true };
         }
@@ -49783,6 +49881,10 @@ function isPathRelativeToParent(path) {
 function getDefaultResolutionModeForFile(file, host, compilerOptions) {
   return isFullSourceFile(file) ? host.getDefaultResolutionModeForFile(file) : getDefaultResolutionModeForFileWorker(file, compilerOptions);
 }
+function prefersTsExtension(allowedEndings) {
+  const tsPriority = allowedEndings.indexOf(3 /* TsExtension */);
+  return tsPriority > -1 && tsPriority < allowedEndings.indexOf(2 /* JsExtension */);
+}
 
 // src/compiler/checker.ts
 var ambientModuleSymbolRegex = /^".+"$/;
@@ -53977,6 +54079,7 @@ function createTypeChecker(host) {
   }
   function symbolToString(symbol, enclosingDeclaration, meaning, flags = 4 /* AllowAnyNodeKind */, writer) {
     let nodeFlags = 70221824 /* IgnoreErrors */;
+    let internalNodeFlags = 0 /* None */;
     if (flags & 2 /* UseOnlyExternalAliasing */) {
       nodeFlags |= 128 /* UseOnlyExternalAliasing */;
     }
@@ -53987,15 +54090,15 @@ function createTypeChecker(host) {
       nodeFlags |= 16384 /* UseAliasDefinedOutsideCurrentScope */;
     }
     if (flags & 32 /* DoNotIncludeSymbolChain */) {
-      nodeFlags |= 134217728 /* DoNotIncludeSymbolChain */;
+      internalNodeFlags |= 4 /* DoNotIncludeSymbolChain */;
     }
     if (flags & 16 /* WriteComputedProps */) {
-      nodeFlags |= 1073741824 /* WriteComputedProps */;
+      internalNodeFlags |= 1 /* WriteComputedProps */;
     }
     const builder = flags & 4 /* AllowAnyNodeKind */ ? nodeBuilder.symbolToNode : nodeBuilder.symbolToEntityName;
     return writer ? symbolToStringWorker(writer).getText() : usingSingleLineStringWriter(symbolToStringWorker);
     function symbolToStringWorker(writer2) {
-      const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
+      const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags, internalNodeFlags);
       const printer = (enclosingDeclaration == null ? void 0 : enclosingDeclaration.kind) === 307 /* SourceFile */ ? createPrinterWithRemoveCommentsNeverAsciiEscape() : createPrinterWithRemoveComments();
       const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
       printer.writeNode(
@@ -54032,7 +54135,13 @@ function createTypeChecker(host) {
   }
   function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
     const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
-    const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0));
+    const typeNode = nodeBuilder.typeToTypeNode(
+      type,
+      enclosingDeclaration,
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
+      /*internalFlags*/
+      void 0
+    );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
     const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
@@ -54081,31 +54190,31 @@ function createTypeChecker(host) {
   }
   function createNodeBuilder() {
     return {
-      typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (declaration, type, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeTypeForDeclaration(context, declaration, type, symbol)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
         /*typeNode*/
         void 0
       )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToName(
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
         symbol,
         context,
         meaning,
         /*expectsIdentifier*/
         false
       )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -54127,13 +54236,13 @@ function createTypeChecker(host) {
       return setTextRange(setOriginalNode(range, location), location);
     }
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
-      const oldFlags = context.flags;
-      if (expr && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+      const restoreFlags = saveRestoreFlags(context);
+      if (expr && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
         syntacticNodeBuilder.serializeTypeOfExpression(expr, context, addUndefined);
       }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
+      context.internalFlags |= 2 /* NoSyntacticPrinter */;
       const result = expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined);
-      context.flags = oldFlags;
+      restoreFlags();
       return result;
     }
     function expressionOrTypeToTypeNodeHelper(context, expr, type, addUndefined) {
@@ -54186,7 +54295,7 @@ function createTypeChecker(host) {
       return void 0;
     }
     function symbolToNode(symbol, context, meaning) {
-      if (context.flags & 1073741824 /* WriteComputedProps */) {
+      if (context.internalFlags & 1 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
           const name = getNameOfDeclaration(symbol.valueDeclaration);
           if (name && isComputedPropertyName(name)) return name;
@@ -54199,12 +54308,13 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext2(enclosingDeclaration, flags, tracker, cb) {
-      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
+    function withContext2(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+      const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
         enclosingFile: enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration),
         flags: flags || 0 /* None */,
+        internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
         encounteredError: false,
         reportedDiagnostic: false,
@@ -54234,14 +54344,23 @@ function createTypeChecker(host) {
       }
       return context.encounteredError ? void 0 : resultingNode;
     }
+    function saveRestoreFlags(context) {
+      const flags = context.flags;
+      const internalFlags = context.internalFlags;
+      return restore;
+      function restore() {
+        context.flags = flags;
+        context.internalFlags = internalFlags;
+      }
+    }
     function checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
     function typeToTypeNodeHelper(type, context) {
-      const savedFlags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       const typeNode = typeToTypeNodeWorker(type, context);
-      context.flags = savedFlags;
+      restoreFlags();
       return typeNode;
     }
     function typeToTypeNodeWorker(type, context) {
@@ -54695,7 +54814,7 @@ function createTypeChecker(host) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
         const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
-        const key = `${getTypeId(type2)}|${context.flags}`;
+        const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
         }
@@ -54801,10 +54920,10 @@ function createTypeChecker(host) {
           }
           return typeToTypeNodeHelper(getIntersectionType(types), context);
         }
-        const savedFlags = context.flags;
+        const restoreFlags = saveRestoreFlags(context);
         context.flags |= 4194304 /* InObjectTypeLiteral */;
         const members = createTypeNodesFromResolvedType(resolved);
-        context.flags = savedFlags;
+        restoreFlags();
         const typeLiteralNode = factory.createTypeLiteralNode(members);
         context.approximateLength += 2;
         setEmitFlags(typeLiteralNode, context.flags & 1024 /* MultilineObjectLiterals */ ? 0 : 1 /* SingleLine */);
@@ -54867,10 +54986,10 @@ function createTypeChecker(host) {
               } while (i < length2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent2);
               if (!rangeEquals(outerTypeParameters, typeArguments, start, i)) {
                 const typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context);
-                const flags2 = context.flags;
+                const restoreFlags2 = saveRestoreFlags(context);
                 context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
                 const ref = symbolToTypeNode(parent2, context, 788968 /* Type */, typeArgumentSlice);
-                context.flags = flags2;
+                restoreFlags2();
                 resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
               }
             }
@@ -54908,10 +55027,10 @@ function createTypeChecker(host) {
             }
             typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
           }
-          const flags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
           const finalRef = symbolToTypeNode(type2.symbol, context, 788968 /* Type */, typeArgumentNodes);
-          context.flags = flags;
+          restoreFlags();
           return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
         }
       }
@@ -55223,7 +55342,7 @@ function createTypeChecker(host) {
           }
         }
         if (seenNames) {
-          const saveContextFlags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 64 /* UseFullyQualifiedType */;
           seenNames.forEach((types2) => {
             if (!arrayIsHomogeneous(types2, ([a], [b]) => typesAreSameReference(a, b))) {
@@ -55232,7 +55351,7 @@ function createTypeChecker(host) {
               }
             }
           });
-          context.flags = saveContextFlags;
+          restoreFlags();
         }
         return result;
       }
@@ -55284,19 +55403,19 @@ function createTypeChecker(host) {
       } else {
         typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
       }
-      const flags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       context.flags &= ~256 /* SuppressAnyReturnType */;
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      context.flags = flags;
+      restoreFlags();
       const returnTypeNode = serializeReturnTypeForSignature(context, signature);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags2 = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
+        const flags = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -55516,13 +55635,13 @@ function createTypeChecker(host) {
       }
     }
     function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
-      const savedContextFlags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       context.flags &= ~512 /* WriteTypeParametersInQualifiedName */;
       const modifiers = factory.createModifiersFromModifierFlags(getTypeParameterModifiers(type));
       const name = typeParameterToName(type, context);
       const defaultParameter = getDefaultFromTypeParameter(type);
       const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
-      context.flags = savedContextFlags;
+      restoreFlags();
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
@@ -55626,7 +55745,7 @@ function createTypeChecker(host) {
     function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
       let chain;
       const isTypeParameter = symbol.flags & 262144 /* TypeParameter */;
-      if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.flags & 134217728 /* DoNotIncludeSymbolChain */)) {
+      if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.internalFlags & 4 /* DoNotIncludeSymbolChain */)) {
         chain = Debug.checkDefined(getSymbolChain(
           symbol,
           meaning,
@@ -56152,19 +56271,19 @@ function createTypeChecker(host) {
       var _a, _b;
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
-      const oldFlags = context.flags;
-      if (declaration && hasInferredType(declaration) && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+      const restoreFlags = saveRestoreFlags(context);
+      if (declaration && hasInferredType(declaration) && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
         syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context);
       }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
-      if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
+      context.internalFlags |= 2 /* NoSyntacticPrinter */;
+      if (enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */)) {
         const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol);
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
           const addUndefined = addUndefinedForParameter || !!(symbol.flags & 4 /* Property */ && symbol.flags & 16777216 /* Optional */ && isOptionalDeclaration(declWithExistingAnnotation) && ((_a = symbol.links) == null ? void 0 : _a.mappedType) && containsNonMissingUndefinedType(type));
           const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
-            context.flags = oldFlags;
+            restoreFlags();
             return result2;
           }
         }
@@ -56175,7 +56294,7 @@ function createTypeChecker(host) {
       const decl = declaration ?? symbol.valueDeclaration ?? ((_b = symbol.declarations) == null ? void 0 : _b[0]);
       const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
       const result = expressionOrTypeToTypeNode(context, expr, type, addUndefinedForParameter);
-      context.flags = oldFlags;
+      restoreFlags();
       return result;
     }
     function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) {
@@ -56189,26 +56308,26 @@ function createTypeChecker(host) {
     }
     function serializeReturnTypeForSignature(context, signature) {
       const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      const flags = context.flags;
+      const restoreFlags = saveRestoreFlags(context);
       if (suppressAny) context.flags &= ~256 /* SuppressAnyReturnType */;
       let returnTypeNode;
       const returnType = getReturnTypeOfSignature(signature);
       if (returnType && !(suppressAny && isTypeAny(returnType))) {
-        if (signature.declaration && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+        if (signature.declaration && !(context.internalFlags & 2 /* NoSyntacticPrinter */)) {
           syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, context);
         }
-        context.flags |= -2147483648 /* NoSyntacticPrinter */;
+        context.internalFlags |= 2 /* NoSyntacticPrinter */;
         returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
       } else if (!suppressAny) {
         returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
       }
-      context.flags = flags;
+      restoreFlags();
       return returnTypeNode;
     }
     function serializeReturnTypeForSignatureWorker(context, signature) {
       const typePredicate = getTypePredicateOfSignature(signature);
       const type = getReturnTypeOfSignature(signature);
-      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+      if (context.enclosingDeclaration && (!isErrorType(type) || context.internalFlags & 8 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(signature.declaration)) {
         const annotation = getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
         if (annotation) {
           const result = tryReuseExistingTypeNode(context, annotation, type, context.enclosingDeclaration);
@@ -56710,7 +56829,7 @@ function createTypeChecker(host) {
           if (!hasDynamicName(node)) {
             return visitEachChild2(node, visitExistingNodeTreeSymbols);
           }
-          if (!(context.flags & 1 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
+          if (!(context.internalFlags & 8 /* AllowUnresolvedNames */ && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
             return void 0;
           }
         }
@@ -57362,7 +57481,7 @@ function createTypeChecker(host) {
         const typeParamDecls = map(typeParams, (p) => typeParameterToDeclaration(p, context));
         const jsdocAliasDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isJSDocTypeAlias);
         const commentText = getTextOfJSDocComment(jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : void 0);
-        const oldFlags = context.flags;
+        const restoreFlags = saveRestoreFlags(context);
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
@@ -57386,7 +57505,7 @@ function createTypeChecker(host) {
           ),
           modifierFlags
         );
-        context.flags = oldFlags;
+        restoreFlags();
         context.enclosingDeclaration = oldEnclosingDecl;
       }
       function serializeInterface(symbol, symbolName2, modifierFlags) {
@@ -58395,10 +58514,10 @@ function createTypeChecker(host) {
       }
       function getNameCandidateWorker(symbol, localName) {
         if (localName === "default" /* Default */ || localName === "__class" /* Class */ || localName === "__function" /* Function */) {
-          const flags = context.flags;
+          const restoreFlags = saveRestoreFlags(context);
           context.flags |= 16777216 /* InInitialEntityName */;
           const nameCandidate = getNameOfSymbolAsWritten(symbol, context);
-          context.flags = flags;
+          restoreFlags();
           localName = nameCandidate.length > 0 && isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? stripQuotes(nameCandidate) : nameCandidate;
         }
         if (localName === "default" /* Default */) {
@@ -59981,7 +60100,8 @@ function createTypeChecker(host) {
       if (!node) {
         return void 0;
       }
-      switch (node.kind) {
+      const kind = node.kind;
+      switch (kind) {
         case 263 /* ClassDeclaration */:
         case 231 /* ClassExpression */:
         case 264 /* InterfaceDeclaration */:
@@ -60003,13 +60123,19 @@ function createTypeChecker(host) {
         case 200 /* MappedType */:
         case 194 /* ConditionalType */: {
           const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
-          if (node.kind === 200 /* MappedType */) {
+          if ((kind === 218 /* FunctionExpression */ || kind === 219 /* ArrowFunction */ || isObjectLiteralMethod(node)) && isContextSensitive(node)) {
+            const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfDeclaration(node)), 0 /* Call */));
+            if (signature && signature.typeParameters) {
+              return [...outerTypeParameters || emptyArray, ...signature.typeParameters];
+            }
+          }
+          if (kind === 200 /* MappedType */) {
             return append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter)));
-          } else if (node.kind === 194 /* ConditionalType */) {
+          } else if (kind === 194 /* ConditionalType */) {
             return concatenate(outerTypeParameters, getInferTypeParameters(node));
           }
           const outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(node));
-          const thisType = includeThisTypes && (node.kind === 263 /* ClassDeclaration */ || node.kind === 231 /* ClassExpression */ || node.kind === 264 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfDeclaration(node)).thisType;
+          const thisType = includeThisTypes && (kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 264 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfDeclaration(node)).thisType;
           return thisType ? append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
         }
         case 341 /* JSDocParameterTag */:
@@ -62821,8 +62947,11 @@ function createTypeChecker(host) {
       true
     );
   }
+  function getTypeParametersForMapper(signature) {
+    return sameMap(signature.typeParameters, (tp) => tp.mapper ? instantiateType(tp, tp.mapper) : tp);
+  }
   function createSignatureTypeMapper(signature, typeArguments) {
-    return createTypeMapper(sameMap(signature.typeParameters, (tp) => tp.mapper ? instantiateType(tp, tp.mapper) : tp), typeArguments);
+    return createTypeMapper(getTypeParametersForMapper(signature), typeArguments);
   }
   function getErasedSignature(signature) {
     return signature.typeParameters ? signature.erasedSignatureCache || (signature.erasedSignatureCache = createErasedSignature(signature)) : signature;
@@ -75836,7 +75965,7 @@ function createTypeChecker(host) {
       type,
       (t) => {
         var _a;
-        if (isGenericMappedType(t) && !t.declaration.nameType) {
+        if (isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */) {
           const constraint = getConstraintTypeFromMappedType(t);
           const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
           const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
@@ -78522,7 +78651,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
-    const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
+    const context = createInferenceContext(getTypeParametersForMapper(signature), signature, 0 /* None */, compareTypes);
     const restType = getEffectiveRestType(contextualSignature);
     const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
@@ -90559,14 +90688,14 @@ function createTypeChecker(host) {
       return 11 /* ObjectType */;
     }
   }
-  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker) {
+  function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
     if (!declaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
     const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
@@ -90609,14 +90738,14 @@ function createTypeChecker(host) {
     }
     return candidateExpr;
   }
-  function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
+  function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, internalFlags, tracker);
   }
-  function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
+  function createTypeOfExpression(exprIn, enclosingDeclaration, flags, internalFlags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
     if (!expr) {
       return factory.createToken(133 /* AnyKeyword */);
@@ -90629,6 +90758,7 @@ function createTypeChecker(host) {
       void 0,
       enclosingDeclaration,
       flags | 1024 /* MultilineObjectLiterals */,
+      internalFlags,
       tracker
     );
   }
@@ -90734,6 +90864,8 @@ function createTypeChecker(host) {
       enclosing,
       /*flags*/
       void 0,
+      /*internalFlags*/
+      void 0,
       tracker
     ) : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
     if (enumResult) return enumResult;
@@ -90862,15 +90994,15 @@ function createTypeChecker(host) {
         const parseDecl = getParseTreeNode(decl);
         return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
       },
-      getDeclarationStatementsForSourceFile: (node, flags, tracker) => {
+      getDeclarationStatementsForSourceFile: (node, flags, internalFlags, tracker) => {
         const n = getParseTreeNode(node);
         Debug.assert(n && n.kind === 307 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
         const sym = getSymbolOfDeclaration(node);
         if (!sym) {
-          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
+          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, internalFlags, tracker);
         }
         resolveExternalModuleSymbol(sym);
-        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
+        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, internalFlags, tracker);
       },
       isImportRequiredByAugmentation,
       isDefinitelyReferenceToGlobalSymbolObject
@@ -96024,7 +96156,6 @@ function transformTypeScript(context) {
   let currentNamespaceContainerName;
   let currentLexicalScope;
   let currentScopeFirstDeclarationsOfName;
-  let currentClassHasParameterProperties;
   let enabledSubstitutions;
   let applicableSubstitutions;
   return transformSourceFileOrBundle;
@@ -96052,14 +96183,12 @@ function transformTypeScript(context) {
   function saveStateAndInvoke(node, f) {
     const savedCurrentScope = currentLexicalScope;
     const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
-    const savedCurrentClassHasParameterProperties = currentClassHasParameterProperties;
     onBeforeVisitNode(node);
     const visited = f(node);
     if (currentLexicalScope !== savedCurrentScope) {
       currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
     }
     currentLexicalScope = savedCurrentScope;
-    currentClassHasParameterProperties = savedCurrentClassHasParameterProperties;
     return visited;
   }
   function onBeforeVisitNode(node) {
@@ -96692,7 +96821,7 @@ function transformTypeScript(context) {
   }
   function visitPropertyNameOfClassElement(member) {
     const name = member.name;
-    if (isComputedPropertyName(name) && (!hasStaticModifier(member) && currentClassHasParameterProperties || hasDecorators(member) && legacyDecorators)) {
+    if (legacyDecorators && isComputedPropertyName(name) && hasDecorators(member)) {
       const expression = visitNode(name.expression, visitor, isExpression);
       Debug.assert(expression);
       const innerExpression = skipPartiallyEmittedExpressions(expression);
@@ -116155,7 +116284,8 @@ function getDeclarationDiagnostics(host, resolver, file) {
     false
   ).diagnostics : void 0;
 }
-var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitInternalNodeBuilderFlags = 8 /* AllowUnresolvedNames */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
   let getSymbolAccessibilityDiagnostic = throwDiagnostic;
@@ -116311,7 +116441,7 @@ function transformDeclarations(context) {
       diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
       errorNode: s.errorNode || sourceFile
     };
-    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker);
+    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
     getSymbolAccessibilityDiagnostic = oldDiag;
     return result;
   }
@@ -116581,7 +116711,7 @@ function transformDeclarations(context) {
       case 172 /* PropertyDeclaration */:
       case 208 /* BindingElement */:
       case 260 /* VariableDeclaration */:
-        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
         break;
       case 262 /* FunctionDeclaration */:
       case 180 /* ConstructSignature */:
@@ -116589,7 +116719,7 @@ function transformDeclarations(context) {
       case 174 /* MethodDeclaration */:
       case 177 /* GetAccessor */:
       case 179 /* CallSignature */:
-        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
         break;
       default:
         Debug.assertNever(node);
@@ -117190,7 +117320,7 @@ function transformDeclarations(context) {
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker),
+            resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
             /*initializer*/
             void 0
           );
@@ -117316,7 +117446,7 @@ function transformDeclarations(context) {
               return void 0;
             }
             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
-            const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags | -2147483648 /* NoSyntacticPrinter */, symbolTracker);
+            const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags | 2 /* NoSyntacticPrinter */, symbolTracker);
             getSymbolAccessibilityDiagnostic = oldDiag;
             const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
             const name = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
@@ -117519,7 +117649,7 @@ function transformDeclarations(context) {
             newId,
             /*exclamationToken*/
             void 0,
-            resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, symbolTracker),
+            resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker),
             /*initializer*/
             void 0
           );
@@ -138309,7 +138439,7 @@ function getTypeNodeIfAccessible(type, enclosingScope, program, host) {
   const checker = program.getTypeChecker();
   let typeIsAccessible = true;
   const notAccessible = () => typeIsAccessible = false;
-  const res = checker.typeToTypeNode(type, enclosingScope, 1 /* NoTruncation */, {
+  const res = checker.typeToTypeNode(type, enclosingScope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */, {
     trackSymbol: (symbol, declaration, meaning) => {
       typeIsAccessible = typeIsAccessible && checker.isSymbolAccessible(
         symbol,
@@ -144166,7 +144296,7 @@ function updateImportsInOtherFiles(changes, program, host, oldFile, movedSymbols
         deleteUnusedImports(sourceFile, importNode, changes, shouldMove);
         const pathToTargetFileWithExtension = resolvePath(getDirectoryPath(getNormalizedAbsolutePath(oldFile.fileName, program.getCurrentDirectory())), targetFileName);
         if (getStringComparer(!program.useCaseSensitiveFileNames())(pathToTargetFileWithExtension, sourceFile.fileName) === 0 /* EqualTo */) return;
-        const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
+        const newModuleSpecifier = ts_moduleSpecifiers_exports.getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
         const newImportDeclaration = filterImport(importNode, makeStringLiteral(newModuleSpecifier, quotePreference), shouldMove);
         if (newImportDeclaration) changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);
         const ns = getNamespaceLikeImport(importNode);
@@ -147233,7 +147363,7 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
     if (!isJS) {
       let type = checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node);
       type = checker.getBaseTypeOfLiteralType(type);
-      typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, 1 /* NoTruncation */);
+      typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
     }
     const paramDecl = factory.createParameterDeclaration(
       /*modifiers*/
@@ -147262,7 +147392,7 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
   )) : void 0;
   if (isExpression(node) && !isJS) {
     const contextualType = checker.getContextualType(node);
-    returnType = checker.typeToTypeNode(contextualType, scope, 1 /* NoTruncation */);
+    returnType = checker.typeToTypeNode(contextualType, scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   }
   const { body, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & 1 /* HasReturn */));
   suppressLeadingAndTrailingTrivia(body);
@@ -147302,7 +147432,8 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
           checker.typeToTypeNode(
             checker.getTypeAtLocation(range.thisNode),
             scope,
-            1 /* NoTruncation */
+            1 /* NoTruncation */,
+            8 /* AllowUnresolvedNames */
           ),
           /*initializer*/
           void 0
@@ -147399,7 +147530,8 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
         const variableType = checker.typeToTypeNode(
           checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(variableDeclaration)),
           scope,
-          1 /* NoTruncation */
+          1 /* NoTruncation */,
+          8 /* AllowUnresolvedNames */
         );
         typeElements.push(factory.createPropertySignature(
           /*modifiers*/
@@ -147530,7 +147662,7 @@ function extractConstantInScope(node, scope, { substitutions }, rangeFacts, cont
   const file = scope.getSourceFile();
   const localNameText = getIdentifierForNode(node, scope, checker, file);
   const isJS = isInJSFile(scope);
-  let variableType = isJS || !checker.isContextSensitive(node) ? void 0 : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NoTruncation */);
+  let variableType = isJS || !checker.isContextSensitive(node) ? void 0 : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   let initializer = transformConstantInitializer(skipParentheses(node), substitutions);
   ({ variableType, initializer } = transformFunctionInitializerAndType(variableType, initializer));
   suppressLeadingAndTrailingTrivia(initializer);
@@ -147655,13 +147787,13 @@ function extractConstantInScope(node, scope, { substitutions }, rangeFacts, cont
       } else {
         const paramType = checker.getTypeAtLocation(p);
         if (paramType === checker.getAnyType()) hasAny = true;
-        parameters.push(factory.updateParameterDeclaration(p, p.modifiers, p.dotDotDotToken, p.name, p.questionToken, p.type || checker.typeToTypeNode(paramType, scope, 1 /* NoTruncation */), p.initializer));
+        parameters.push(factory.updateParameterDeclaration(p, p.modifiers, p.dotDotDotToken, p.name, p.questionToken, p.type || checker.typeToTypeNode(paramType, scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */), p.initializer));
       }
     }
     if (hasAny) return { variableType: variableType2, initializer: initializer2 };
     variableType2 = void 0;
     if (isArrowFunction(initializer2)) {
-      initializer2 = factory.updateArrowFunction(initializer2, canHaveModifiers(node) ? getModifiers(node) : void 0, initializer2.typeParameters, parameters, initializer2.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NoTruncation */), initializer2.equalsGreaterThanToken, initializer2.body);
+      initializer2 = factory.updateArrowFunction(initializer2, canHaveModifiers(node) ? getModifiers(node) : void 0, initializer2.typeParameters, parameters, initializer2.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */), initializer2.equalsGreaterThanToken, initializer2.body);
     } else {
       if (functionSignature && !!functionSignature.thisParameter) {
         const firstParameter = firstOrUndefined(parameters);
@@ -147678,7 +147810,7 @@ function extractConstantInScope(node, scope, { substitutions }, rangeFacts, cont
               "this",
               /*questionToken*/
               void 0,
-              checker.typeToTypeNode(thisType, scope, 1 /* NoTruncation */)
+              checker.typeToTypeNode(thisType, scope, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */)
             )
           );
         }
@@ -148299,7 +148431,7 @@ function getInfo4(context) {
     if (signature) {
       const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
       if (typePredicate && typePredicate.type) {
-        const typePredicateTypeNode = typeChecker.typePredicateToTypePredicateNode(typePredicate, declaration, 1 /* NoTruncation */);
+        const typePredicateTypeNode = typeChecker.typePredicateToTypePredicateNode(typePredicate, declaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
         if (typePredicateTypeNode) {
           return { declaration, returnTypeNode: typePredicateTypeNode };
         }
@@ -148311,7 +148443,7 @@ function getInfo4(context) {
   if (!returnType) {
     return { error: getLocaleSpecificMessage(Diagnostics.Could_not_determine_function_return_type) };
   }
-  const returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NoTruncation */);
+  const returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   if (returnTypeNode) {
     return { declaration, returnTypeNode };
   }
@@ -154823,6 +154955,8 @@ function addMissingDeclarations(context, implementedTypeNode, sourceFile, classD
         classDeclaration,
         /*flags*/
         void 0,
+        /*internalFlags*/
+        void 0,
         getNoopSymbolTrackerWithResolver(context)
       ));
     }
@@ -156454,6 +156588,8 @@ function addMissingConstraint(changes, program, preferences, host, sourceFile, i
       scriptTarget,
       /*flags*/
       void 0,
+      /*internalFlags*/
+      void 0,
       tracker
     );
     if (typeNode) {
@@ -157561,14 +157697,15 @@ function getTypeNode2(checker, node, token) {
     const binaryExpression = token.parent.parent;
     const otherExpression = token.parent === binaryExpression.left ? binaryExpression.right : binaryExpression.left;
     const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(otherExpression)));
-    typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NoTruncation */);
+    typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */);
   } else {
     const contextualType = checker.getContextualType(token.parent);
     typeNode = contextualType ? checker.typeToTypeNode(
       contextualType,
       /*enclosingDeclaration*/
       void 0,
-      1 /* NoTruncation */
+      1 /* NoTruncation */,
+      8 /* AllowUnresolvedNames */
     ) : void 0;
   }
   return typeNode || factory.createKeywordTypeNode(133 /* AnyKeyword */);
@@ -157890,7 +158027,9 @@ function createPropertyNameFromSymbol(symbol, target, quotePreference, checker)
       111551 /* Value */,
       /*enclosingDeclaration*/
       void 0,
-      1073741824 /* WriteComputedProps */
+      /*flags*/
+      void 0,
+      1 /* WriteComputedProps */
     );
     if (prop && isComputedPropertyName(prop)) return prop;
   }
@@ -158063,7 +158202,7 @@ function tryGetName2(node) {
   }
 }
 function typeToTypeNode(checker, type, enclosingDeclaration) {
-  return checker.typeToTypeNode(checker.getWidenedType(type), enclosingDeclaration, 1 /* NoTruncation */) ?? factory.createKeywordTypeNode(159 /* UnknownKeyword */);
+  return checker.typeToTypeNode(checker.getWidenedType(type), enclosingDeclaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */) ?? factory.createKeywordTypeNode(159 /* UnknownKeyword */);
 }
 function doChange19(changes, program, preferences, host, declarations, newParameters) {
   const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
@@ -159366,7 +159505,8 @@ var canHaveTypeAnnotation = /* @__PURE__ */ new Set([
   206 /* ObjectBindingPattern */,
   207 /* ArrayBindingPattern */
 ]);
-var declarationEmitNodeBuilderFlags2 = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */ | 1073741824 /* WriteComputedProps */;
+var declarationEmitNodeBuilderFlags2 = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitInternalNodeBuilderFlags2 = 1 /* WriteComputedProps */;
 registerCodeFix({
   errorCodes: errorCodes47,
   fixIds: [fixId36],
@@ -160152,7 +160292,7 @@ function withContext(context, typePrintMode, cb) {
   }
   function typeToTypeNode2(type, enclosingDeclaration, flags = 0 /* None */) {
     let isTruncated = false;
-    const result2 = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, {
+    const result2 = typeToAutoImportableTypeNode(typeChecker, importAdder, type, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, declarationEmitInternalNodeBuilderFlags2, {
       moduleResolverHost: program,
       trackSymbol() {
         return true;
@@ -160165,7 +160305,7 @@ function withContext(context, typePrintMode, cb) {
   }
   function typePredicateToTypeNode(typePredicate, enclosingDeclaration, flags = 0 /* None */) {
     let isTruncated = false;
-    const result2 = typePredicateToAutoImportableTypeNode(typeChecker, importAdder, typePredicate, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, {
+    const result2 = typePredicateToAutoImportableTypeNode(typeChecker, importAdder, typePredicate, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, declarationEmitInternalNodeBuilderFlags2, {
       moduleResolverHost: program,
       trackSymbol() {
         return true;
@@ -161492,7 +161632,7 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
     case 172 /* PropertyDeclaration */:
       let flags = 1 /* NoTruncation */;
       flags |= quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0;
-      let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
+      let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
       if (importAdder) {
         const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
         if (importableReference) {
@@ -161517,6 +161657,8 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
         enclosingDeclaration,
         /*flags*/
         void 0,
+        /*internalFlags*/
+        void 0,
         getNoopSymbolTrackerWithResolver(context)
       );
       const allAccessors = getAllAccessorDeclarations(declarations, declaration);
@@ -161646,7 +161788,7 @@ function createSignatureDeclarationFromSignature(kind, context, quotePreference,
   const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
   const isJs = isInJSFile(enclosingDeclaration);
   const flags = 1 /* NoTruncation */ | 256 /* SuppressAnyReturnType */ | 524288 /* AllowEmptyTuple */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
-  const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
+  const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
   if (!signatureDeclaration) {
     return void 0;
   }
@@ -161747,6 +161889,7 @@ function createSignatureDeclarationFromCallExpression(kind, context, importAdder
     contextNode,
     scriptTarget,
     1 /* NoTruncation */,
+    8 /* AllowUnresolvedNames */,
     tracker
   );
   const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : void 0;
@@ -161765,6 +161908,8 @@ function createSignatureDeclarationFromCallExpression(kind, context, importAdder
     contextNode,
     /*flags*/
     void 0,
+    /*internalFlags*/
+    void 0,
     tracker
   );
   switch (kind) {
@@ -161834,8 +161979,8 @@ function createTypeParametersForArguments(checker, argumentTypeParameters, typeA
 function createTypeParameterName(index) {
   return 84 /* T */ + index <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + index) : `T${index}`;
 }
-function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
-  let typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
+function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, internalFlags, tracker) {
+  let typeNode = checker.typeToTypeNode(type, contextNode, flags, internalFlags, tracker);
   if (typeNode && isImportTypeNode(typeNode)) {
     const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
     if (importableReference) {
@@ -161845,8 +161990,8 @@ function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, s
   }
   return getSynthesizedDeepClone(typeNode);
 }
-function typePredicateToAutoImportableTypeNode(checker, importAdder, typePredicate, contextNode, scriptTarget, flags, tracker) {
-  let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, tracker);
+function typePredicateToAutoImportableTypeNode(checker, importAdder, typePredicate, contextNode, scriptTarget, flags, internalFlags, tracker) {
+  let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, internalFlags, tracker);
   if ((typePredicateNode == null ? void 0 : typePredicateNode.type) && isImportTypeNode(typePredicateNode.type)) {
     const importableReference = tryGetAutoImportableReferenceFromTypeNode(typePredicateNode.type, scriptTarget);
     if (importableReference) {
@@ -161862,7 +162007,7 @@ function typeContainsTypeParameter(type) {
   }
   return type.flags & 262144 /* TypeParameter */;
 }
-function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, tracker) {
+function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, internalFlags, tracker) {
   const argumentTypeNodes = [];
   const argumentTypeParameters = /* @__PURE__ */ new Map();
   for (let i = 0; i < instanceTypes.length; i += 1) {
@@ -161874,13 +162019,13 @@ function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes,
       continue;
     }
     const widenedInstanceType = checker.getBaseTypeOfLiteralType(instanceType);
-    const argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, tracker);
+    const argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, internalFlags, tracker);
     if (!argumentTypeNode) {
       continue;
     }
     argumentTypeNodes.push(argumentTypeNode);
     const argumentTypeParameter = getFirstTypeParameterName(instanceType);
-    const instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint) ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, tracker) : void 0;
+    const instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint) ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, internalFlags, tracker) : void 0;
     if (argumentTypeParameter) {
       argumentTypeParameters.set(argumentTypeParameter, { argumentType: instanceType, constraint: instanceTypeConstraint });
     }
@@ -161980,7 +162125,7 @@ function createMethodImplementingSignatures(checker, context, enclosingDeclarati
 function getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration) {
   if (length(signatures)) {
     const type = checker.getUnionType(map(signatures, checker.getReturnTypeOfSignature));
-    return checker.typeToTypeNode(type, enclosingDeclaration, 1 /* NoTruncation */, getNoopSymbolTrackerWithResolver(context));
+    return checker.typeToTypeNode(type, enclosingDeclaration, 1 /* NoTruncation */, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
   }
 }
 function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference, body) {
@@ -163266,9 +163411,9 @@ function originIsComputedPropertyName(origin) {
   return !!(origin && origin.kind & 512 /* ComputedPropertyName */);
 }
 function resolvingModuleSpecifiers(logPrefix, host, resolver, program, position, preferences, isForImportStatementCompletion, isValidTypeOnlyUseSite, cb) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const start = timestamp();
-  const needsFullResolution = isForImportStatementCompletion || moduleResolutionSupportsPackageJsonExportsAndImports(getEmitModuleResolutionKind(program.getCompilerOptions()));
+  const needsFullResolution = isForImportStatementCompletion || getResolvePackageJsonExports(program.getCompilerOptions()) || ((_a = preferences.autoImportSpecifierExcludeRegexes) == null ? void 0 : _a.length);
   let skippedAny = false;
   let ambientCount = 0;
   let resolvedCount = 0;
@@ -163281,9 +163426,9 @@ function resolvingModuleSpecifiers(logPrefix, host, resolver, program, position,
     resolvedBeyondLimit: () => resolvedCount > moduleSpecifierResolutionLimit
   });
   const hitRateMessage = cacheAttemptCount ? ` (${(resolvedFromCacheCount / cacheAttemptCount * 100).toFixed(1)}% hit rate)` : "";
-  (_a = host.log) == null ? void 0 : _a.call(host, `${logPrefix}: resolved ${resolvedCount} module specifiers, plus ${ambientCount} ambient and ${resolvedFromCacheCount} from cache${hitRateMessage}`);
-  (_b = host.log) == null ? void 0 : _b.call(host, `${logPrefix}: response is ${skippedAny ? "incomplete" : "complete"}`);
-  (_c = host.log) == null ? void 0 : _c.call(host, `${logPrefix}: ${timestamp() - start}`);
+  (_b = host.log) == null ? void 0 : _b.call(host, `${logPrefix}: resolved ${resolvedCount} module specifiers, plus ${ambientCount} ambient and ${resolvedFromCacheCount} from cache${hitRateMessage}`);
+  (_c = host.log) == null ? void 0 : _c.call(host, `${logPrefix}: response is ${skippedAny ? "incomplete" : "complete"}`);
+  (_d = host.log) == null ? void 0 : _d.call(host, `${logPrefix}: ${timestamp() - start}`);
   return result;
   function tryResolve(exportInfo, isFromAmbientModule) {
     if (isFromAmbientModule) {
@@ -164555,7 +164700,14 @@ function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, pro
       if (signatures.length !== 1) {
         return void 0;
       }
-      const typeNode = checker.typeToTypeNode(effectiveType, enclosingDeclaration, builderFlags, ts_codefix_exports.getNoopSymbolTrackerWithResolver({ program, host }));
+      const typeNode = checker.typeToTypeNode(
+        effectiveType,
+        enclosingDeclaration,
+        builderFlags,
+        /*internalFlags*/
+        void 0,
+        ts_codefix_exports.getNoopSymbolTrackerWithResolver({ program, host })
+      );
       if (!typeNode || !isFunctionTypeNode(typeNode)) {
         return void 0;
       }
@@ -166788,7 +166940,13 @@ function getJsDocTagAtPosition(node, position) {
 }
 function getPropertiesForObjectExpression(contextualType, completionsType, obj, checker) {
   const hasCompletionsType = completionsType && completionsType !== contextualType;
-  const type = hasCompletionsType && !(completionsType.flags & 3 /* AnyOrUnknown */) ? checker.getUnionType([contextualType, completionsType]) : contextualType;
+  const promiseFilteredContextualType = checker.getUnionType(
+    filter(
+      contextualType.flags & 1048576 /* Union */ ? contextualType.types : [contextualType],
+      (t) => !checker.getPromisedTypeOfPromise(t)
+    )
+  );
+  const type = hasCompletionsType && !(completionsType.flags & 3 /* AnyOrUnknown */) ? checker.getUnionType([promiseFilteredContextualType, completionsType]) : promiseFilteredContextualType;
   const properties = getApparentProperties(type, obj, checker);
   return type.isClass() && containsNonPublicProperties(properties) ? [] : hasCompletionsType ? filter(properties, hasDeclarationOtherThanSelf) : properties;
   function hasDeclarationOtherThanSelf(member) {
@@ -167659,7 +167817,7 @@ function getFilenameWithExtensionOption(name, program, extensionOptions, isExpor
   if (extensionOptions.referenceKind === 0 /* Filename */) {
     return { name, extension: tryGetExtensionFromPath2(name) };
   }
-  let allowedEndings = getModuleSpecifierPreferences(
+  let allowedEndings = ts_moduleSpecifiers_exports.getModuleSpecifierPreferences(
     { importModuleSpecifierEnding: extensionOptions.endingPreference },
     program,
     program.getCompilerOptions(),
@@ -179235,6 +179393,7 @@ __export(ts_exports2, {
   InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
+  InternalNodeBuilderFlags: () => InternalNodeBuilderFlags,
   InternalSymbolName: () => InternalSymbolName,
   IntersectionFlags: () => IntersectionFlags,
   InvalidatedProjectKind: () => InvalidatedProjectKind,
@@ -180222,6 +180381,7 @@ __export(ts_exports2, {
   hasEffectiveModifiers: () => hasEffectiveModifiers,
   hasEffectiveReadonlyModifier: () => hasEffectiveReadonlyModifier,
   hasExtension: () => hasExtension,
+  hasImplementationTSFileExtension: () => hasImplementationTSFileExtension,
   hasIndexSignature: () => hasIndexSignature,
   hasInferredType: () => hasInferredType,
   hasInitializer: () => hasInitializer,
@@ -193620,6 +193780,7 @@ if (typeof console !== "undefined") {
   InlayHintKind,
   InlayHints,
   InternalEmitFlags,
+  InternalNodeBuilderFlags,
   InternalSymbolName,
   IntersectionFlags,
   InvalidatedProjectKind,
@@ -194607,6 +194768,7 @@ if (typeof console !== "undefined") {
   hasEffectiveModifiers,
   hasEffectiveReadonlyModifier,
   hasExtension,
+  hasImplementationTSFileExtension,
   hasIndexSignature,
   hasInferredType,
   hasInitializer,