@typescript-deploys/pr-build 5.7.0-pr-56941-53 → 5.7.0-pr-57718-9

package/lib/typescript.js

@@ -945,6 +945,7 @@ __export(typescript_exports, {
   getPositionOfLineAndCharacter: () => getPositionOfLineAndCharacter,
   getPossibleGenericSignatures: () => getPossibleGenericSignatures,
   getPossibleOriginalInputExtensionForExtension: () => getPossibleOriginalInputExtensionForExtension,
+  getPossibleOriginalInputPathWithoutChangingExt: () => getPossibleOriginalInputPathWithoutChangingExt,
   getPossibleTypeArgumentsInfo: () => getPossibleTypeArgumentsInfo,
   getPreEmitDiagnostics: () => getPreEmitDiagnostics,
   getPrecedingNonSpaceCharacterPosition: () => getPrecedingNonSpaceCharacterPosition,
@@ -2277,7 +2278,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-insiders.20241007`;
+var version = `${versionMajorMinor}.0-insiders.20241031`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6530,7 +6531,6 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
   ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
-  ObjectFlags3[ObjectFlags3["IsNarrowedType"] = 16777216] = "IsNarrowedType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -18874,12 +18874,12 @@ function canHaveFlowNode(node) {
     case 80 /* Identifier */:
     case 110 /* ThisKeyword */:
     case 108 /* SuperKeyword */:
-    case 212 /* ElementAccessExpression */:
-    case 211 /* PropertyAccessExpression */:
-    case 218 /* FunctionExpression */:
     case 166 /* QualifiedName */:
     case 236 /* MetaProperty */:
+    case 212 /* ElementAccessExpression */:
+    case 211 /* PropertyAccessExpression */:
     case 208 /* BindingElement */:
+    case 218 /* FunctionExpression */:
     case 219 /* ArrowFunction */:
     case 174 /* MethodDeclaration */:
     case 177 /* GetAccessor */:
@@ -19885,7 +19885,7 @@ function hasInvalidEscape(template) {
 }
 var doubleQuoteEscapedCharsRegExp = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g;
 var singleQuoteEscapedCharsRegExp = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g;
-var backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u001f\u2028\u2029\u0085]/g;
+var backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g;
 var escapedCharsMap = new Map(Object.entries({
   "	": "\\t",
   "\v": "\\v",
@@ -20205,6 +20205,12 @@ function getDeclarationEmitExtensionForPath(path) {
 function getPossibleOriginalInputExtensionForExtension(path) {
   return fileExtensionIsOneOf(path, [".d.mts" /* Dmts */, ".mjs" /* Mjs */, ".mts" /* Mts */]) ? [".mts" /* Mts */, ".mjs" /* Mjs */] : fileExtensionIsOneOf(path, [".d.cts" /* Dcts */, ".cjs" /* Cjs */, ".cts" /* Cts */]) ? [".cts" /* Cts */, ".cjs" /* Cjs */] : fileExtensionIsOneOf(path, [`.d.json.ts`]) ? [".json" /* Json */] : [".tsx" /* Tsx */, ".ts" /* Ts */, ".jsx" /* Jsx */, ".js" /* Js */];
 }
+function getPossibleOriginalInputPathWithoutChangingExt(filePath, ignoreCase, outputDir, getCommonSourceDirectory2) {
+  return outputDir ? resolvePath(
+    getCommonSourceDirectory2(),
+    getRelativePathFromDirectory(outputDir, filePath, ignoreCase)
+  ) : filePath;
+}
 function getPathsBasePath(options, host) {
   var _a;
   if (!options.paths) return void 0;
@@ -21263,11 +21269,11 @@ function getLastChild(node) {
   });
   return lastChild;
 }
-function addToSeen(seen, key, value = true) {
+function addToSeen(seen, key) {
   if (seen.has(key)) {
     return false;
   }
-  seen.set(key, value);
+  seen.add(key);
   return true;
 }
 function isObjectTypeDeclaration(node) {
@@ -30140,13 +30146,23 @@ var importStarHelper = {
   dependencies: [createBindingHelper, setModuleDefaultHelper],
   priority: 2,
   text: `
-            var __importStar = (this && this.__importStar) || function (mod) {
-                if (mod && mod.__esModule) return mod;
-                var result = {};
-                if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-                __setModuleDefault(result, mod);
-                return result;
-            };`
+            var __importStar = (this && this.__importStar) || (function () {
+                var ownKeys = function(o) {
+                    ownKeys = Object.getOwnPropertyNames || function (o) {
+                        var ar = [];
+                        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+                        return ar;
+                    };
+                    return ownKeys(o);
+                };
+                return function (mod) {
+                    if (mod && mod.__esModule) return mod;
+                    var result = {};
+                    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+                    __setModuleDefault(result, mod);
+                    return result;
+                };
+            })();`
 };
 var importDefaultHelper = {
   name: "typescript:commonjsimportdefault",
@@ -33784,10 +33800,12 @@ var Parser;
       case 90 /* DefaultKeyword */:
         return nextTokenCanFollowDefaultKeyword();
       case 126 /* StaticKeyword */:
+        nextToken();
+        return canFollowModifier();
       case 139 /* GetKeyword */:
       case 153 /* SetKeyword */:
         nextToken();
-        return canFollowModifier();
+        return canFollowGetOrSetKeyword();
       default:
         return nextTokenIsOnSameLineAndCanFollowModifier();
     }
@@ -33805,6 +33823,9 @@ var Parser;
   function canFollowModifier() {
     return token() === 23 /* OpenBracketToken */ || token() === 19 /* OpenBraceToken */ || token() === 42 /* AsteriskToken */ || token() === 26 /* DotDotDotToken */ || isLiteralPropertyName();
   }
+  function canFollowGetOrSetKeyword() {
+    return token() === 23 /* OpenBracketToken */ || isLiteralPropertyName();
+  }
   function nextTokenCanFollowDefaultKeyword() {
     nextToken();
     return token() === 86 /* ClassKeyword */ || token() === 100 /* FunctionKeyword */ || token() === 120 /* InterfaceKeyword */ || token() === 60 /* AtToken */ || token() === 128 /* AbstractKeyword */ && lookAhead(nextTokenIsClassKeywordOnSameLine) || token() === 134 /* AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine);
@@ -42425,7 +42446,7 @@ function convertToTSConfig(configParseResult, configFileName, host) {
   const providedKeys = new Set(optionMap.keys());
   const impliedCompilerOptions = {};
   for (const option in computedOptions) {
-    if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) {
+    if (!providedKeys.has(option) && optionDependsOn(option, providedKeys)) {
       const implied = computedOptions[option].computeValue(configParseResult.options);
       const defaultValue = computedOptions[option].computeValue({});
       if (implied !== defaultValue) {
@@ -42436,6 +42457,17 @@ function convertToTSConfig(configParseResult, configFileName, host) {
   assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
   return config;
 }
+function optionDependsOn(option, dependsOn) {
+  const seen = /* @__PURE__ */ new Set();
+  return optionDependsOnRecursive(option);
+  function optionDependsOnRecursive(option2) {
+    var _a;
+    if (addToSeen(seen, option2)) {
+      return some((_a = computedOptions[option2]) == null ? void 0 : _a.dependencies, (dep) => dependsOn.has(dep) || optionDependsOnRecursive(dep));
+    }
+    return false;
+  }
+}
 function optionMapToObject(optionMap) {
   return Object.fromEntries(optionMap);
 }
@@ -44844,25 +44876,28 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
       return toSearchResult({ resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
     }
     if (!isExternalModuleNameRelative(moduleName)) {
-      let resolved2;
       if (features & 2 /* Imports */ && startsWith(moduleName, "#")) {
-        resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
-      }
-      if (!resolved2 && features & 4 /* SelfName */) {
-        resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        const resolved3 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        if (resolved3) {
+          return resolved3.value && { value: { resolved: resolved3.value, isExternalLibraryImport: false } };
+        }
       }
-      if (!resolved2) {
-        if (moduleName.includes(":")) {
-          if (traceEnabled) {
-            trace(host, Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
-          }
-          return void 0;
+      if (features & 4 /* SelfName */) {
+        const resolved3 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        if (resolved3) {
+          return resolved3.value && { value: { resolved: resolved3.value, isExternalLibraryImport: false } };
         }
+      }
+      if (moduleName.includes(":")) {
         if (traceEnabled) {
-          trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
+          trace(host, Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
         }
-        resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        return void 0;
       }
+      if (traceEnabled) {
+        trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
+      }
+      let resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
       if (extensions2 & 4 /* Declaration */) {
         resolved2 ?? (resolved2 = resolveFromTypeRoot(moduleName, state2));
       }
@@ -45405,7 +45440,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec
       mainExport = scope.contents.packageJsonContent.exports["."];
     }
     if (mainExport) {
-      const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(
+      const loadModuleFromTargetExportOrImport = getLoadModuleFromTargetExportOrImport(
         extensions,
         state,
         cache,
@@ -45415,7 +45450,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec
         /*isImports*/
         false
       );
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         mainExport,
         "",
         /*pattern*/
@@ -45433,7 +45468,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec
         void 0
       );
     }
-    const result = loadModuleFromImportsOrExports(
+    const result = loadModuleFromExportsOrImports(
       extensions,
       state,
       cache,
@@ -45487,7 +45522,7 @@ function loadModuleFromImports(extensions, moduleName, directory, state, cache,
       void 0
     );
   }
-  const result = loadModuleFromImportsOrExports(
+  const result = loadModuleFromExportsOrImports(
     extensions,
     state,
     cache,
@@ -45522,11 +45557,11 @@ function comparePatternKeys(a, b) {
   if (b.length > a.length) return 1 /* GreaterThan */;
   return 0 /* EqualTo */;
 }
-function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
-  const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
+function loadModuleFromExportsOrImports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
+  const loadModuleFromTargetExportOrImport = getLoadModuleFromTargetExportOrImport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
   if (!endsWith(moduleName, directorySeparator) && !moduleName.includes("*") && hasProperty(lookupTable, moduleName)) {
     const target = lookupTable[moduleName];
-    return loadModuleFromTargetImportOrExport(
+    return loadModuleFromTargetExportOrImport(
       target,
       /*subpath*/
       "",
@@ -45541,7 +45576,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe
       const target = lookupTable[potentialTarget];
       const starPos = potentialTarget.indexOf("*");
       const subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos));
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         target,
         subpath,
         /*pattern*/
@@ -45551,7 +45586,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe
     } else if (endsWith(potentialTarget, "*") && startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) {
       const target = lookupTable[potentialTarget];
       const subpath = moduleName.substring(potentialTarget.length - 1);
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         target,
         subpath,
         /*pattern*/
@@ -45561,7 +45596,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe
     } else if (startsWith(moduleName, potentialTarget)) {
       const target = lookupTable[potentialTarget];
       const subpath = moduleName.substring(potentialTarget.length);
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         target,
         subpath,
         /*pattern*/
@@ -45581,9 +45616,9 @@ function hasOneAsterisk(patternKey) {
   const firstStar = patternKey.indexOf("*");
   return firstStar !== -1 && firstStar === patternKey.lastIndexOf("*");
 }
-function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
-  return loadModuleFromTargetImportOrExport;
-  function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) {
+function getLoadModuleFromTargetExportOrImport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
+  return loadModuleFromTargetExportOrImport;
+  function loadModuleFromTargetExportOrImport(target, subpath, pattern, key) {
     if (typeof target === "string") {
       if (!pattern && subpath.length > 0 && !endsWith(target, "/")) {
         if (state.traceEnabled) {
@@ -45673,7 +45708,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
           if (condition === "default" || state.conditions.includes(condition) || isApplicableVersionedTypesKey(state.conditions, condition)) {
             traceIfEnabled(state, Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition);
             const subTarget = target[condition];
-            const result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key);
+            const result = loadModuleFromTargetExportOrImport(subTarget, subpath, pattern, key);
             if (result) {
               traceIfEnabled(state, Diagnostics.Resolved_under_condition_0, condition);
               traceIfEnabled(state, Diagnostics.Exiting_conditional_exports);
@@ -45698,7 +45733,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
           );
         }
         for (const elem of target) {
-          const result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key);
+          const result = loadModuleFromTargetExportOrImport(elem, subpath, pattern, key);
           if (result) {
             return result;
           }
@@ -46376,7 +46411,6 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
-  var inReturnStatement;
   var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
@@ -46449,7 +46483,6 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
-    inReturnStatement = false;
     hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
@@ -47214,10 +47247,7 @@ function createBinder() {
     currentFlow = finishFlowLabel(postIfLabel);
   }
   function bindReturnOrThrow(node) {
-    const oldInReturnStatement = inReturnStatement;
-    inReturnStatement = true;
     bind(node.expression);
-    inReturnStatement = oldInReturnStatement;
     if (node.kind === 253 /* ReturnStatement */) {
       hasExplicitReturn = true;
       if (currentReturnTarget) {
@@ -47578,16 +47608,10 @@ function createBinder() {
     hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
-    if (inReturnStatement) {
-      node.flowNodeWhenTrue = currentFlow;
-    }
     bind(node.questionToken);
     bind(node.whenTrue);
     addAntecedent(postExpressionLabel, currentFlow);
     currentFlow = finishFlowLabel(falseLabel);
-    if (inReturnStatement) {
-      node.flowNodeWhenFalse = currentFlow;
-    }
     bind(node.colonToken);
     bind(node.whenFalse);
     addAntecedent(postExpressionLabel, currentFlow);
@@ -49605,31 +49629,29 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
         return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true };
       }
     }
-    if (!specifier) {
-      const local = getLocalModuleSpecifier(
-        modulePath.path,
-        info,
-        compilerOptions,
-        host,
-        options.overrideImportMode || importingSourceFile.impliedNodeFormat,
-        preferences,
-        /*pathsOnly*/
-        modulePath.isRedirect
-      );
-      if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) {
-        continue;
-      }
-      if (modulePath.isRedirect) {
-        redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
-      } else if (pathIsBareSpecifier(local)) {
-        if (pathContainsNodeModules(local)) {
-          relativeSpecifiers = append(relativeSpecifiers, local);
-        } else {
-          pathsSpecifiers = append(pathsSpecifiers, local);
-        }
-      } else if (forAutoImport || !importedFileIsInNodeModules || modulePath.isInNodeModules) {
+    const local = getLocalModuleSpecifier(
+      modulePath.path,
+      info,
+      compilerOptions,
+      host,
+      options.overrideImportMode || importingSourceFile.impliedNodeFormat,
+      preferences,
+      /*pathsOnly*/
+      modulePath.isRedirect || !!specifier
+    );
+    if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) {
+      continue;
+    }
+    if (modulePath.isRedirect) {
+      redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
+    } else if (pathIsBareSpecifier(local)) {
+      if (pathContainsNodeModules(local)) {
         relativeSpecifiers = append(relativeSpecifiers, local);
+      } else {
+        pathsSpecifiers = append(pathsSpecifiers, local);
       }
+    } else if (forAutoImport || !importedFileIsInNodeModules || modulePath.isInNodeModules) {
+      relativeSpecifiers = append(relativeSpecifiers, local);
     }
   }
   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 };
@@ -49675,7 +49697,7 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
     importMode,
     prefersTsExtension(allowedEndings)
   );
-  const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) : void 0;
+  const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, baseDirectory, getCanonicalFileName, host, compilerOptions) : void 0;
   if (pathsOnly) {
     return fromPaths;
   }
@@ -49904,10 +49926,11 @@ function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) {
     return ambientModuleDeclare.name.text;
   }
 }
-function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
+function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, baseDirectory, getCanonicalFileName, host, compilerOptions) {
   for (const key in paths) {
     for (const patternText2 of paths[key]) {
-      const pattern = normalizePath(patternText2);
+      const normalized = normalizePath(patternText2);
+      const pattern = getRelativePathIfInSameVolume(normalized, baseDirectory, getCanonicalFileName) ?? normalized;
       const indexOfStar = pattern.indexOf("*");
       const candidates = allowedEndings.map((ending) => ({
         ending,
@@ -50236,6 +50259,8 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
           subModuleName,
           versionPaths.paths,
           allowedEndings,
+          packageRootPath,
+          getCanonicalFileName,
           host,
           options
         );
@@ -50531,7 +50556,7 @@ function createTypeChecker(host) {
   var scanner2;
   var Symbol48 = objectAllocator.getSymbolConstructor();
   var Type29 = objectAllocator.getTypeConstructor();
-  var Signature14 = objectAllocator.getSignatureConstructor();
+  var Signature13 = objectAllocator.getSignatureConstructor();
   var typeCount = 0;
   var symbolCount = 0;
   var totalInstantiationCount = 0;
@@ -51530,7 +51555,6 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
-  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -54894,6 +54918,9 @@ function createTypeChecker(host) {
           }
         }
         let annotationType = getTypeFromTypeNodeWithoutContext(existing);
+        if (isErrorType(annotationType)) {
+          return true;
+        }
         if (requiresAddingUndefined && annotationType) {
           annotationType = getOptionalType(annotationType, !isParameter(node));
         }
@@ -55920,7 +55947,7 @@ function createTypeChecker(host) {
         const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 32768 /* Undefined */)), 0 /* Call */);
         for (const signature of signatures) {
           const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 173 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken });
-          typeElements.push(preserveCommentsOn(methodDeclaration));
+          typeElements.push(preserveCommentsOn(methodDeclaration, signature.declaration || propertySymbol.valueDeclaration));
         }
         if (signatures.length || !optionalToken) {
           return;
@@ -55955,8 +55982,8 @@ function createTypeChecker(host) {
         optionalToken,
         propertyTypeNode
       );
-      typeElements.push(preserveCommentsOn(propertySignature));
-      function preserveCommentsOn(node) {
+      typeElements.push(preserveCommentsOn(propertySignature, propertySymbol.valueDeclaration));
+      function preserveCommentsOn(node, range) {
         var _a2;
         const jsdocPropertyTag = (_a2 = propertySymbol.declarations) == null ? void 0 : _a2.find((d) => d.kind === 348 /* JSDocPropertyTag */);
         if (jsdocPropertyTag) {
@@ -55964,8 +55991,8 @@ function createTypeChecker(host) {
           if (commentText) {
             setSyntheticLeadingComments(node, [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
           }
-        } else if (propertySymbol.valueDeclaration) {
-          setCommentRange2(context, node, propertySymbol.valueDeclaration);
+        } else if (range) {
+          setCommentRange2(context, node, range);
         }
         return node;
       }
@@ -60077,7 +60104,7 @@ function createTypeChecker(host) {
       const getter = getDeclarationOfKind(symbol, 177 /* GetAccessor */);
       const setter = getDeclarationOfKind(symbol, 178 /* SetAccessor */);
       const accessor = tryCast(getDeclarationOfKind(symbol, 172 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
-      let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration(
+      let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && getWidenedTypeForVariableLikeDeclaration(
         accessor,
         /*reportErrors*/
         true
@@ -61176,7 +61203,7 @@ function createTypeChecker(host) {
     resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments);
   }
   function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) {
-    const sig = new Signature14(checker, flags);
+    const sig = new Signature13(checker, flags);
     sig.declaration = declaration;
     sig.typeParameters = typeParameters;
     sig.parameters = parameters;
@@ -63760,14 +63787,11 @@ function createTypeChecker(host) {
   function isNoInferType(type) {
     return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
   }
-  function isNarrowingSubstitutionType(type) {
-    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowedType */);
+  function getSubstitutionType(baseType, constraint) {
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
   }
-  function getSubstitutionType(baseType, constraint, isNarrowed) {
-    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint, isNarrowed);
-  }
-  function getOrCreateSubstitutionType(baseType, constraint, isNarrowed) {
-    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}${isNarrowed ? ">N" : ""}`;
+  function getOrCreateSubstitutionType(baseType, constraint) {
+    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
       return cached;
@@ -63775,9 +63799,6 @@ function createTypeChecker(host) {
     const result = createType(33554432 /* Substitution */);
     result.baseType = baseType;
     result.constraint = constraint;
-    if (isNarrowed) {
-      result.objectFlags |= 16777216 /* IsNarrowedType */;
-    }
     substitutionTypes.set(id, result);
     return result;
   }
@@ -65980,7 +66001,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -65997,11 +66018,10 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
-      const effectiveCheckType = forNarrowing && isNarrowingSubstitutionType(checkType) ? checkType.constraint : checkType;
       const checkTypeNode = skipTypeParentheses(root.node.checkType);
       const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
       const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
-      const checkTypeDeferred = isDeferredType(effectiveCheckType, checkTuples);
+      const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
         const context = createInferenceContext(
@@ -66020,8 +66040,8 @@ function createTypeChecker(host) {
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
-        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (effectiveCheckType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(effectiveCheckType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (effectiveCheckType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(effectiveCheckType)))) {
+        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
+          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -66038,7 +66058,7 @@ function createTypeChecker(host) {
           result = instantiateType(falseType2, mapper);
           break;
         }
-        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(effectiveCheckType), getRestrictiveInstantiation(inferredExtendsType))) {
+        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
           const trueType2 = getTypeFromTypeNode(root.node.trueType);
           const trueMapper = combinedMapper || mapper;
           if (canTailRecurse(trueType2, trueMapper)) {
@@ -66229,7 +66249,7 @@ function createTypeChecker(host) {
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
       const aliasSymbol = getAliasSymbolForTypeNode(node);
-      if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
+      if (!node.symbol || getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
         links.resolvedType = emptyTypeLiteralType;
       } else {
         let type = createObjectType(16 /* Anonymous */, node.symbol);
@@ -67004,44 +67024,8 @@ function createTypeChecker(host) {
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
-        let distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
-        let narrowingBaseType;
-        const forNarrowing = distributionType && isNarrowingSubstitutionType(distributionType) && isNarrowableConditionalType(type, mapper);
-        if (forNarrowing) {
-          narrowingBaseType = distributionType.baseType;
-          distributionType = getReducedType(distributionType.constraint);
-        }
-        if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
-          const mapperCallback = narrowingBaseType ? (t) => getConditionalType(
-            root,
-            prependTypeMapping(checkType, getSubstitutionType(
-              narrowingBaseType,
-              t,
-              /*isNarrowed*/
-              true
-            ), newMapper),
-            forConstraint,
-            /*aliasSymbol*/
-            void 0,
-            /*aliasTypeArguments*/
-            void 0,
-            forNarrowing
-          ) : (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint);
-          if (narrowingBaseType) {
-            result = mapType(
-              distributionType,
-              mapperCallback,
-              /*noReductions*/
-              void 0,
-              /*toIntersection*/
-              true
-            );
-          } else {
-            result = mapTypeWithAlias(distributionType, mapperCallback, aliasSymbol, aliasTypeArguments);
-          }
-        } else {
-          result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
-        }
+        const distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
+        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
         root.instantiations.set(id, result);
       }
       return result;
@@ -67154,9 +67138,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function isGenericIndexedOrConditionalReturnType(type) {
-    return !!(type.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */) && couldContainTypeVariables(type));
-  }
   function instantiateReverseMappedType(type, mapper) {
     const innerMappedType = instantiateType(type.mappedType, mapper);
     if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
@@ -68187,12 +68168,10 @@ function createTypeChecker(host) {
   function shouldNormalizeIntersection(type) {
     let hasInstantiable = false;
     let hasNullableOrEmpty = false;
-    let hasSubstitution = false;
     for (const t of type.types) {
       hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
       hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
-      hasSubstitution || (hasSubstitution = isNarrowingSubstitutionType(t));
-      if (hasInstantiable && hasNullableOrEmpty || hasSubstitution) return true;
+      if (hasInstantiable && hasNullableOrEmpty) return true;
     }
     return false;
   }
@@ -73327,7 +73306,7 @@ function createTypeChecker(host) {
   function countTypes(type) {
     return type.flags & 1048576 /* Union */ ? type.types.length : 1;
   }
-  function mapType(type, mapper, noReductions, toIntersection) {
+  function mapType(type, mapper, noReductions) {
     if (type.flags & 131072 /* Never */) {
       return type;
     }
@@ -73349,7 +73328,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    return changed ? mappedTypes && (toIntersection ? getIntersectionType(mappedTypes) : getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */)) : type;
+    return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
   }
   function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
     return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
@@ -74702,12 +74681,14 @@ function createTypeChecker(host) {
         case 80 /* Identifier */:
           if (!isMatchingReference(reference, expr) && inlineLevel < 5) {
             const symbol = getResolvedSymbol(expr);
-            const inlineExpression = getNarrowableInlineExpression(symbol);
-            if (inlineExpression && isConstantReference(reference)) {
-              inlineLevel++;
-              const result = narrowType(type, inlineExpression, assumeTrue);
-              inlineLevel--;
-              return result;
+            if (isConstantVariable(symbol)) {
+              const declaration = symbol.valueDeclaration;
+              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) {
+                inlineLevel++;
+                const result = narrowType(type, declaration.initializer, assumeTrue);
+                inlineLevel--;
+                return result;
+              }
             }
           }
         // falls through
@@ -74742,14 +74723,6 @@ function createTypeChecker(host) {
       return type;
     }
   }
-  function getNarrowableInlineExpression(symbol) {
-    if (isConstantVariable(symbol)) {
-      const declaration = symbol.valueDeclaration;
-      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer) {
-        return declaration.initializer;
-      }
-    }
-  }
   function getTypeOfSymbolAtLocation(symbol, location) {
     symbol = getExportSymbolOfValueSymbolIfExported(symbol);
     if (location.kind === 80 /* Identifier */ || location.kind === 81 /* PrivateIdentifier */) {
@@ -74939,11 +74912,11 @@ function createTypeChecker(host) {
     ));
     return contextualType && !isGenericType(contextualType);
   }
-  function getNarrowableTypeForReference(type, reference, checkMode, forReturnTypeNarrowing) {
+  function getNarrowableTypeForReference(type, reference, checkMode) {
     if (isNoInferType(type)) {
       type = type.baseType;
     }
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (forReturnTypeNarrowing || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -76068,16 +76041,9 @@ function createTypeChecker(host) {
   function getContextualTypeForReturnExpression(node, contextFlags) {
     const func = getContainingFunction(node);
     if (func) {
-      const functionFlags = getFunctionFlags(func);
-      const links = getNodeLinks(node);
-      if (links.contextualReturnType) {
-        if (functionFlags & 2 /* Async */) {
-          return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
-        }
-        return links.contextualReturnType;
-      }
       let contextualReturnType = getContextualReturnType(func, contextFlags);
       if (contextualReturnType) {
+        const functionFlags = getFunctionFlags(func);
         if (functionFlags & 1 /* Generator */) {
           const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
           if (contextualReturnType.flags & 1048576 /* Union */) {
@@ -76775,13 +76741,6 @@ function createTypeChecker(host) {
     if (index >= 0) {
       return contextualTypes[index];
     }
-    const links = getNodeLinks(node);
-    if (links.contextualReturnType) {
-      if (node.flags & 65536 /* AwaitContext */) {
-        return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
-      }
-      return links.contextualReturnType;
-    }
     const { parent: parent2 } = node;
     switch (parent2.kind) {
       case 260 /* VariableDeclaration */:
@@ -87221,7 +87180,7 @@ function createTypeChecker(host) {
       return anyIterationTypes;
     }
     if (!(type.flags & 1048576 /* Union */)) {
-      const errorOutputContainer = errorNode ? { errors: void 0 } : void 0;
+      const errorOutputContainer = errorNode ? { errors: void 0, skipLogging: true } : void 0;
       const iterationTypes2 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer);
       if (iterationTypes2 === noIterationTypes) {
         if (errorNode) {
@@ -87389,11 +87348,27 @@ function createTypeChecker(host) {
     if (isTypeAny(methodType)) {
       return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
     }
-    const signatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0;
-    if (!some(signatures)) {
+    const allSignatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0;
+    const validSignatures = filter(allSignatures, (sig) => getMinArgumentCount(sig) === 0);
+    if (!some(validSignatures)) {
+      if (errorNode && some(allSignatures)) {
+        checkTypeAssignableTo(
+          type,
+          resolver.getGlobalIterableType(
+            /*reportErrors*/
+            true
+          ),
+          errorNode,
+          /*headMessage*/
+          void 0,
+          /*containingMessageChain*/
+          void 0,
+          errorOutputContainer
+        );
+      }
       return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
     }
-    const iteratorType = getIntersectionType(map(signatures, getReturnTypeOfSignature));
+    const iteratorType = getIntersectionType(map(validSignatures, getReturnTypeOfSignature));
     const iterationTypes = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache) ?? noIterationTypes;
     return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
   }
@@ -87671,234 +87646,34 @@ function createTypeChecker(host) {
     }
     const signature = getSignatureFromDeclaration(container);
     const returnType = getReturnTypeOfSignature(signature);
+    const functionFlags = getFunctionFlags(container);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
+      const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 178 /* SetAccessor */) {
         if (node.expression) {
           error2(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 176 /* Constructor */) {
-        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
           error2(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
-        checkReturnStatementExpression(container, returnType, node, node.expression);
+        const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
+        const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
+          exprType,
+          /*withAlias*/
+          false,
+          node,
+          Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
+        ) : exprType;
+        if (unwrappedReturnType) {
+          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
+        }
       }
     } else if (container.kind !== 176 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error2(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
-  function checkReturnStatementExpression(container, returnType, node, expr) {
-    const functionFlags = getFunctionFlags(container);
-    const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
-    if (expr) {
-      const unwrappedExpr = skipParentheses(expr);
-      if (isConditionalExpression(unwrappedExpr)) {
-        return checkReturnConditionalExpression(container, returnType, node, unwrappedExpr);
-      }
-    }
-    const exprType = expr ? checkExpressionCached(expr) : undefinedType;
-    const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
-      exprType,
-      /*withAlias*/
-      false,
-      node,
-      Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-    ) : exprType;
-    const errorNode = node.expression && isConditionalExpression(skipParentheses(node.expression)) ? expr : node;
-    if (checkTypeAssignableTo(
-      unwrappedExprType,
-      unwrappedReturnType,
-      /*errorNode*/
-      void 0
-    )) {
-      return;
-    }
-    if (!isGenericIndexedOrConditionalReturnType(unwrappedReturnType)) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
-      return;
-    }
-    const allTypeParameters = appendTypeParameters(getOuterTypeParameters(
-      container,
-      /*includeThisTypes*/
-      false
-    ), getEffectiveTypeParameterDeclarations(container));
-    const narrowableTypeParameters = allTypeParameters && getNarrowableTypeParameters(allTypeParameters);
-    if (!narrowableTypeParameters || !narrowableTypeParameters.length || !isNarrowableReturnType(unwrappedReturnType)) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
-      return;
-    }
-    let narrowPosition = node;
-    let narrowFlowNode = node.flowNode;
-    if (expr && isConditionalExpression(expr.parent)) {
-      narrowFlowNode = expr.parent.whenTrue === expr ? expr.parent.flowNodeWhenTrue : expr.parent.flowNodeWhenFalse;
-      narrowPosition = expr;
-    }
-    if (!narrowFlowNode) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
-      return;
-    }
-    const narrowed = mapDefined(narrowableTypeParameters, ([typeParam, symbol, reference]) => {
-      const narrowReference = factory.cloneNode(reference);
-      narrowReference.id = void 0;
-      getNodeLinks(narrowReference).resolvedSymbol = symbol;
-      setParent(narrowReference, narrowPosition.parent);
-      narrowReference.flowNode = narrowFlowNode;
-      const initialType = getNarrowableTypeForReference(
-        typeParam,
-        narrowReference,
-        /*checkMode*/
-        void 0,
-        /*forReturnTypeNarrowing*/
-        true
-      );
-      if (initialType === typeParam) {
-        return void 0;
-      }
-      const flowType = getFlowTypeOfReference(narrowReference, initialType);
-      const exprType2 = getTypeFromFlowType(flowType);
-      if (isTypeAny(exprType2) || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
-        return void 0;
-      }
-      const narrowedType = getSubstitutionType(
-        typeParam,
-        exprType2,
-        /*isNarrowed*/
-        true
-      );
-      return [typeParam, narrowedType];
-    });
-    const narrowMapper = createTypeMapper(narrowed.map(([tp, _]) => tp), narrowed.map(([_, t]) => t));
-    const narrowedReturnType = instantiateType(
-      unwrappedReturnType,
-      narrowMapper
-    );
-    if (expr) {
-      const links = getNodeLinks(expr);
-      if (!links.contextualReturnType) {
-        links.contextualReturnType = narrowedReturnType;
-      }
-    }
-    const narrowedExprType = expr ? checkExpression(expr) : undefinedType;
-    const narrowedUnwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
-      narrowedExprType,
-      /*withAlias*/
-      false,
-      node,
-      Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-    ) : narrowedExprType;
-    checkTypeAssignableToAndOptionallyElaborate(narrowedUnwrappedExprType, narrowedReturnType, errorNode, expr);
-  }
-  function checkReturnConditionalExpression(container, returnType, node, expr) {
-    checkExpression(expr.condition);
-    checkReturnStatementExpression(container, returnType, node, expr.whenTrue);
-    checkReturnStatementExpression(container, returnType, node, expr.whenFalse);
-  }
-  function getNarrowableTypeParameters(candidates) {
-    const narrowableParams = [];
-    for (const typeParam of candidates) {
-      const constraint = getConstraintOfTypeParameter(typeParam);
-      if (!constraint || !(constraint.flags & 1048576 /* Union */)) continue;
-      if (typeParam.symbol && typeParam.symbol.declarations && typeParam.symbol.declarations.length === 1) {
-        const container = typeParam.symbol.declarations[0].parent;
-        if (!isFunctionLike(container)) continue;
-        let reference;
-        let hasInvalidReference = false;
-        for (const paramDecl of container.parameters) {
-          const typeNode = paramDecl.type;
-          if (!typeNode) continue;
-          if (isTypeParameterReferenced(typeParam, typeNode)) {
-            let candidateReference;
-            if (isTypeReferenceNode(typeNode) && isReferenceToTypeParameter(typeParam, typeNode) && (candidateReference = getValidParameterReference(paramDecl, constraint))) {
-              if (reference) {
-                hasInvalidReference = true;
-                break;
-              }
-              reference = candidateReference;
-              continue;
-            }
-            hasInvalidReference = true;
-            break;
-          }
-        }
-        if (!hasInvalidReference && reference) {
-          const symbol = getResolvedSymbol(reference);
-          if (symbol !== unknownSymbol) narrowableParams.push([typeParam, symbol, reference]);
-        }
-      }
-    }
-    return narrowableParams;
-    function getValidParameterReference(paramDecl, constraint) {
-      if (!isIdentifier(paramDecl.name)) return;
-      if (paramDecl.questionToken && !containsUndefinedType(constraint)) return;
-      return paramDecl.name;
-    }
-    function isReferenceToTypeParameter(typeParam, node) {
-      return getTypeFromTypeReference(node) === typeParam;
-    }
-    function isTypeParameterReferenced(typeParam, node) {
-      return isReferenced(node);
-      function isReferenced(node2) {
-        if (isTypeReferenceNode(node2)) {
-          return isReferenceToTypeParameter(typeParam, node2);
-        }
-        if (isTypeQueryNode(node2)) {
-          return isTypeParameterPossiblyReferenced(typeParam, node2);
-        }
-        return !!forEachChild(node2, isReferenced);
-      }
-    }
-  }
-  function isNarrowableReturnType(returnType) {
-    return isConditionalType(returnType) ? isNarrowableConditionalType(returnType) : !!(returnType.indexType.flags & 262144 /* TypeParameter */);
-  }
-  function isNarrowableConditionalType(type, mapper) {
-    const typeArguments = mapper && map(type.root.outerTypeParameters, (t) => {
-      const mapped = getMappedType(t, mapper);
-      if (isNarrowingSubstitutionType(mapped)) {
-        return mapped.baseType;
-      }
-      return mapped;
-    });
-    const id = `${type.id}:${getTypeListId(typeArguments)}`;
-    let result = narrowableReturnTypeCache.get(id);
-    if (result === void 0) {
-      const nonNarrowingMapper = type.root.outerTypeParameters && typeArguments && createTypeMapper(type.root.outerTypeParameters, typeArguments);
-      const instantiatedType = instantiateType(type, nonNarrowingMapper);
-      result = isConditionalType(instantiatedType) && isNarrowableConditionalTypeWorker(instantiatedType);
-      narrowableReturnTypeCache.set(id, result);
-    }
-    return result;
-  }
-  function isNarrowableConditionalTypeWorker(type) {
-    if (!type.root.isDistributive) {
-      return false;
-    }
-    if (type.root.inferTypeParameters) {
-      return false;
-    }
-    if (!(type.checkType.flags & 262144 /* TypeParameter */)) {
-      return false;
-    }
-    const constraintType = getConstraintOfTypeParameter(type.checkType);
-    if (!constraintType || !(constraintType.flags & 1048576 /* Union */)) {
-      return false;
-    }
-    if (!everyType(type.extendsType, (extendsType) => some(
-      constraintType.types,
-      (constraintType2) => isTypeIdenticalTo(constraintType2, extendsType)
-    ))) {
-      return false;
-    }
-    const trueType2 = getTrueTypeFromConditionalType(type);
-    const falseType2 = getFalseTypeFromConditionalType(type);
-    const isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2) : true;
-    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2) : falseType2 === neverType;
-    return isValidTrueType && isValidFalseType;
-  }
-  function isConditionalType(type) {
-    return !!(type.flags & 16777216 /* Conditional */);
-  }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
       if (node.flags & 65536 /* AwaitContext */) {
@@ -88827,6 +88602,9 @@ function createTypeChecker(host) {
   }
   function checkInterfaceDeclaration(node) {
     if (!checkGrammarModifiers(node)) checkGrammarInterfaceDeclaration(node);
+    if (!allowBlockDeclarations(node.parent)) {
+      grammarErrorOnNode(node, Diagnostics._0_declarations_can_only_be_declared_inside_a_block, "interface");
+    }
     checkTypeParameters(node.typeParameters);
     addLazyDiagnostic(() => {
       checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);
@@ -88861,6 +88639,9 @@ function createTypeChecker(host) {
   function checkTypeAliasDeclaration(node) {
     checkGrammarModifiers(node);
     checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
+    if (!allowBlockDeclarations(node.parent)) {
+      grammarErrorOnNode(node, Diagnostics._0_declarations_can_only_be_declared_inside_a_block, "type");
+    }
     checkExportsOnMergedDeclarations(node);
     checkTypeParameters(node.typeParameters);
     if (node.type.kind === 141 /* IntrinsicKeyword */) {
@@ -91247,7 +91028,7 @@ function createTypeChecker(host) {
     const typeNode = getNonlocalEffectiveTypeAnnotationNode(parameter);
     if (!typeNode) return false;
     const type = getTypeFromTypeNode(typeNode);
-    return containsUndefinedType(type);
+    return isErrorType(type) || containsUndefinedType(type);
   }
   function requiresAddingImplicitUndefined(parameter, enclosingDeclaration) {
     return (isRequiredInitializedParameter(parameter, enclosingDeclaration) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
@@ -93273,7 +93054,7 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function allowLetAndConstDeclarations(parent2) {
+  function allowBlockDeclarations(parent2) {
     switch (parent2.kind) {
       case 245 /* IfStatement */:
       case 246 /* DoStatement */:
@@ -93284,12 +93065,12 @@ function createTypeChecker(host) {
       case 250 /* ForOfStatement */:
         return false;
       case 256 /* LabeledStatement */:
-        return allowLetAndConstDeclarations(parent2.parent);
+        return allowBlockDeclarations(parent2.parent);
     }
     return true;
   }
   function checkGrammarForDisallowedBlockScopedVariableStatement(node) {
-    if (!allowLetAndConstDeclarations(node.parent)) {
+    if (!allowBlockDeclarations(node.parent)) {
       const blockScopeKind = getCombinedNodeFlagsCached(node.declarationList) & 7 /* BlockScoped */;
       if (blockScopeKind) {
         const keyword = blockScopeKind === 1 /* Let */ ? "let" : blockScopeKind === 2 /* Const */ ? "const" : blockScopeKind === 4 /* Using */ ? "using" : blockScopeKind === 6 /* AwaitUsing */ ? "await using" : Debug.fail("Unknown BlockScope flag");
@@ -96067,9 +95848,9 @@ function getDecoratorsOfParameters(node) {
   }
   return decorators;
 }
-function getAllDecoratorsOfClass(node) {
+function getAllDecoratorsOfClass(node, useLegacyDecorators) {
   const decorators = getDecorators(node);
-  const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node));
+  const parameters = useLegacyDecorators ? getDecoratorsOfParameters(getFirstConstructorWithBody(node)) : void 0;
   if (!some(decorators) && !some(parameters)) {
     return void 0;
   }
@@ -96083,18 +95864,27 @@ function getAllDecoratorsOfClassElement(member, parent2, useLegacyDecorators) {
     case 177 /* GetAccessor */:
     case 178 /* SetAccessor */:
       if (!useLegacyDecorators) {
-        return getAllDecoratorsOfMethod(member);
+        return getAllDecoratorsOfMethod(
+          member,
+          /*useLegacyDecorators*/
+          false
+        );
       }
-      return getAllDecoratorsOfAccessors(member, parent2);
+      return getAllDecoratorsOfAccessors(
+        member,
+        parent2,
+        /*useLegacyDecorators*/
+        true
+      );
     case 174 /* MethodDeclaration */:
-      return getAllDecoratorsOfMethod(member);
+      return getAllDecoratorsOfMethod(member, useLegacyDecorators);
     case 172 /* PropertyDeclaration */:
       return getAllDecoratorsOfProperty(member);
     default:
       return void 0;
   }
 }
-function getAllDecoratorsOfAccessors(accessor, parent2) {
+function getAllDecoratorsOfAccessors(accessor, parent2, useLegacyDecorators) {
   if (!accessor.body) {
     return void 0;
   }
@@ -96104,7 +95894,7 @@ function getAllDecoratorsOfAccessors(accessor, parent2) {
     return void 0;
   }
   const decorators = getDecorators(firstAccessorWithDecorators);
-  const parameters = getDecoratorsOfParameters(setAccessor);
+  const parameters = useLegacyDecorators ? getDecoratorsOfParameters(setAccessor) : void 0;
   if (!some(decorators) && !some(parameters)) {
     return void 0;
   }
@@ -96115,12 +95905,12 @@ function getAllDecoratorsOfAccessors(accessor, parent2) {
     setDecorators: setAccessor && getDecorators(setAccessor)
   };
 }
-function getAllDecoratorsOfMethod(method) {
+function getAllDecoratorsOfMethod(method, useLegacyDecorators) {
   if (!method.body) {
     return void 0;
   }
   const decorators = getDecorators(method);
-  const parameters = getDecoratorsOfParameters(method);
+  const parameters = useLegacyDecorators ? getDecoratorsOfParameters(method) : void 0;
   if (!some(decorators) && !some(parameters)) {
     return void 0;
   }
@@ -101764,7 +101554,11 @@ function transformLegacyDecorators(context) {
     }
   }
   function generateConstructorDecorationExpression(node) {
-    const allDecorators = getAllDecoratorsOfClass(node);
+    const allDecorators = getAllDecoratorsOfClass(
+      node,
+      /*useLegacyDecorators*/
+      true
+    );
     const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators);
     if (!decoratorExpressions) {
       return void 0;
@@ -102276,7 +102070,11 @@ function transformESDecorators(context) {
     let syntheticConstructor;
     let heritageClauses;
     let shouldTransformPrivateStaticElementsInClass = false;
-    const classDecorators = transformAllDecoratorsOfDeclaration(getAllDecoratorsOfClass(node));
+    const classDecorators = transformAllDecoratorsOfDeclaration(getAllDecoratorsOfClass(
+      node,
+      /*useLegacyDecorators*/
+      false
+    ));
     if (classDecorators) {
       classInfo2.classDecoratorsName = factory2.createUniqueName("_classDecorators", 16 /* Optimistic */ | 32 /* FileLevel */);
       classInfo2.classDescriptorName = factory2.createUniqueName("_classDescriptor", 16 /* Optimistic */ | 32 /* FileLevel */);
@@ -121782,15 +121580,88 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     return false;
   }
   function parenthesizeExpressionForNoAsi(node) {
-    if (!commentsDisabled && isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) {
-      const parseNode = getParseTreeNode(node);
-      if (parseNode && isParenthesizedExpression(parseNode)) {
-        const parens = factory.createParenthesizedExpression(node.expression);
-        setOriginalNode(parens, node);
-        setTextRange(parens, parseNode);
-        return parens;
+    if (!commentsDisabled) {
+      switch (node.kind) {
+        case 355 /* PartiallyEmittedExpression */:
+          if (willEmitLeadingNewLine(node)) {
+            const parseNode = getParseTreeNode(node);
+            if (parseNode && isParenthesizedExpression(parseNode)) {
+              const parens = factory.createParenthesizedExpression(node.expression);
+              setOriginalNode(parens, node);
+              setTextRange(parens, parseNode);
+              return parens;
+            }
+            return factory.createParenthesizedExpression(node);
+          }
+          return factory.updatePartiallyEmittedExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression)
+          );
+        case 211 /* PropertyAccessExpression */:
+          return factory.updatePropertyAccessExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.name
+          );
+        case 212 /* ElementAccessExpression */:
+          return factory.updateElementAccessExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.argumentExpression
+          );
+        case 213 /* CallExpression */:
+          return factory.updateCallExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.typeArguments,
+            node.arguments
+          );
+        case 215 /* TaggedTemplateExpression */:
+          return factory.updateTaggedTemplateExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.tag),
+            node.typeArguments,
+            node.template
+          );
+        case 225 /* PostfixUnaryExpression */:
+          return factory.updatePostfixUnaryExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.operand)
+          );
+        case 226 /* BinaryExpression */:
+          return factory.updateBinaryExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.left),
+            node.operatorToken,
+            node.right
+          );
+        case 227 /* ConditionalExpression */:
+          return factory.updateConditionalExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.condition),
+            node.questionToken,
+            node.whenTrue,
+            node.colonToken,
+            node.whenFalse
+          );
+        case 234 /* AsExpression */:
+          return factory.updateAsExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.type
+          );
+        case 238 /* SatisfiesExpression */:
+          return factory.updateSatisfiesExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.type
+          );
+        case 235 /* NonNullExpression */:
+          return factory.updateNonNullExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression)
+          );
       }
-      return factory.createParenthesizedExpression(node);
     }
     return node;
   }
@@ -140630,7 +140501,13 @@ function getDefaultLikeExportNameFromDeclaration(symbol) {
     if (isExportSpecifier(d) && d.symbol.flags === 2097152 /* Alias */) {
       return (_b = tryCast(d.propertyName, isIdentifier)) == null ? void 0 : _b.text;
     }
-    return (_c = tryCast(getNameOfDeclaration(d), isIdentifier)) == null ? void 0 : _c.text;
+    const name = (_c = tryCast(getNameOfDeclaration(d), isIdentifier)) == null ? void 0 : _c.text;
+    if (name) {
+      return name;
+    }
+    if (symbol.parent && !isExternalModuleSymbol(symbol.parent)) {
+      return symbol.parent.getName();
+    }
   });
 }
 function getSymbolParentOrFail(symbol) {
@@ -141221,7 +141098,7 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio
       true,
       (moduleSymbol, moduleFile, program2, isFromPackageJson) => {
         if (++moduleCount % 100 === 0) cancellationToken == null ? void 0 : cancellationToken.throwIfCancellationRequested();
-        const seenExports = /* @__PURE__ */ new Map();
+        const seenExports = /* @__PURE__ */ new Set();
         const checker = program2.getTypeChecker();
         const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
         if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
@@ -141261,7 +141138,11 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio
 }
 function getDefaultLikeExportInfo(moduleSymbol, checker) {
   const exportEquals = checker.resolveExternalModuleSymbol(moduleSymbol);
-  if (exportEquals !== moduleSymbol) return { symbol: exportEquals, exportKind: 2 /* ExportEquals */ };
+  if (exportEquals !== moduleSymbol) {
+    const defaultExport2 = checker.tryGetMemberInModuleExports("default" /* Default */, exportEquals);
+    if (defaultExport2) return { symbol: defaultExport2, exportKind: 1 /* Default */ };
+    return { symbol: exportEquals, exportKind: 2 /* ExportEquals */ };
+  }
   const defaultExport = checker.tryGetMemberInModuleExports("default" /* Default */, moduleSymbol);
   if (defaultExport) return { symbol: defaultExport, exportKind: 1 /* Default */ };
 }
@@ -141279,7 +141160,7 @@ function getNamesForExportedSymbol(defaultExport, checker, scriptTarget) {
 function forEachNameOfDefaultExport(defaultExport, checker, scriptTarget, cb) {
   let chain;
   let current = defaultExport;
-  const seen = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
   while (current) {
     const fromDeclaration = getDefaultLikeExportNameFromDeclaration(current);
     if (fromDeclaration) {
@@ -144828,6 +144709,7 @@ function isSynthesized(node) {
   return !!(node.flags & 16 /* Synthesized */);
 }
 function isOwnChild(n, parent2) {
+  if (n.parent === void 0) return false;
   const par = isModuleBlock(n.parent) ? n.parent.parent : n.parent;
   return par === parent2.node || contains(parent2.additionalNodes, par);
 }
@@ -145744,7 +145626,7 @@ function flattenTypeLiteralNodeReference(checker, selection) {
   }
   if (isIntersectionTypeNode(selection)) {
     const result = [];
-    const seen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     for (const type of selection.types) {
       const flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type);
       if (!flattenedTypeMembers || !flattenedTypeMembers.every((type2) => type2.name && addToSeen(seen, getNameFromPropertyName(type2.name)))) {
@@ -156416,7 +156298,7 @@ registerCodeFix({
   },
   fixIds: [fixId13],
   getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyExport(context) {
-    const fixedExportDeclarations = /* @__PURE__ */ new Map();
+    const fixedExportDeclarations = /* @__PURE__ */ new Set();
     return codeFixAll(context, errorCodes14, (changes, diag2) => {
       const exportSpecifier = getExportSpecifierForDiagnosticSpan(diag2, context.sourceFile);
       if (exportSpecifier && addToSeen(fixedExportDeclarations, getNodeId(exportSpecifier.parent.parent))) {
@@ -156895,7 +156777,7 @@ registerCodeFix({
   },
   fixIds: [fixId17],
   getAllCodeActions(context) {
-    const seenClassDeclarations = /* @__PURE__ */ new Map();
+    const seenClassDeclarations = /* @__PURE__ */ new Set();
     return codeFixAll(context, errorCodes18, (changes, diag2) => {
       const classDeclaration = getClass(diag2.file, diag2.start);
       if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
@@ -157276,7 +157158,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
   function writeFixes(changeTracker, oldFileQuotePreference) {
     var _a, _b;
     let quotePreference;
-    if (isFullSourceFile(sourceFile) && sourceFile.imports.length === 0 && oldFileQuotePreference !== void 0) {
+    if (sourceFile.imports !== void 0 && sourceFile.imports.length === 0 && oldFileQuotePreference !== void 0) {
       quotePreference = oldFileQuotePreference;
     } else {
       quotePreference = getQuotePreference(sourceFile, preferences);
@@ -158522,7 +158404,7 @@ registerCodeFix({
   fixIds: [fixId18],
   getAllCodeActions: (context) => {
     const { program, preferences, host } = context;
-    const seen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
       eachDiagnostic(context, errorCodes20, (diag2) => {
         const info = getInfo6(program, diag2.file, createTextSpan(diag2.start, diag2.length));
@@ -159456,7 +159338,7 @@ registerCodeFix({
   getAllCodeActions: (context) => {
     const { program, fixId: fixId56 } = context;
     const checker = program.getTypeChecker();
-    const seen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     const typeDeclToMembers = /* @__PURE__ */ new Map();
     return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
       eachDiagnostic(context, errorCodes28, (diag2) => {
@@ -159507,7 +159389,7 @@ registerCodeFix({
   }
 });
 function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
-  var _a;
+  var _a, _b, _c;
   const token = getTokenAtPosition(sourceFile, tokenPos);
   const parent2 = token.parent;
   if (errorCode === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) {
@@ -159520,7 +159402,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
     if (!(param && isParameter(param) && isIdentifier(param.name))) return void 0;
     const properties = arrayFrom(checker.getUnmatchedProperties(
       checker.getTypeAtLocation(parent2),
-      checker.getParameterType(signature, argIndex),
+      checker.getParameterType(signature, argIndex).getNonNullableType(),
       /*requireOptionalProperties*/
       false,
       /*matchDiscriminantProperties*/
@@ -159530,7 +159412,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
     return { kind: 3 /* ObjectLiteral */, token: param.name, identifier: param.name.text, properties, parentDeclaration: parent2 };
   }
   if (token.kind === 19 /* OpenBraceToken */ && isObjectLiteralExpression(parent2)) {
-    const targetType = checker.getContextualType(parent2) || checker.getTypeAtLocation(parent2);
+    const targetType = (_a = checker.getContextualType(parent2) || checker.getTypeAtLocation(parent2)) == null ? void 0 : _a.getNonNullableType();
     const properties = arrayFrom(checker.getUnmatchedProperties(
       checker.getTypeAtLocation(parent2),
       targetType,
@@ -159545,7 +159427,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
   }
   if (!isMemberName(token)) return void 0;
   if (isIdentifier(token) && hasInitializer(parent2) && parent2.initializer && isObjectLiteralExpression(parent2.initializer)) {
-    const targetType = checker.getContextualType(token) || checker.getTypeAtLocation(token);
+    const targetType = (_b = checker.getContextualType(token) || checker.getTypeAtLocation(token)) == null ? void 0 : _b.getNonNullableType();
     const properties = arrayFrom(checker.getUnmatchedProperties(
       checker.getTypeAtLocation(parent2.initializer),
       targetType,
@@ -159564,7 +159446,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
     return { kind: 4 /* JsxAttributes */, token, attributes, parentDeclaration: token.parent };
   }
   if (isIdentifier(token)) {
-    const type = (_a = checker.getContextualType(token)) == null ? void 0 : _a.getNonNullableType();
+    const type = (_c = checker.getContextualType(token)) == null ? void 0 : _c.getNonNullableType();
     if (type && getObjectFlags(type) & 16 /* Anonymous */) {
       const signature = firstOrUndefined(checker.getSignaturesOfType(type, 0 /* Call */));
       if (signature === void 0) return void 0;
@@ -159885,8 +159767,9 @@ function tryGetValueFromType(context, checker, importAdder, quotePreference, typ
   }
   if (type.flags & 1056 /* EnumLike */) {
     const enumMember = type.symbol.exports ? firstOrUndefinedIterator(type.symbol.exports.values()) : type.symbol;
+    const symbol = type.symbol.parent && type.symbol.parent.flags & 256 /* RegularEnum */ ? type.symbol.parent : type.symbol;
     const name = checker.symbolToExpression(
-      type.symbol.parent ? type.symbol.parent : type.symbol,
+      symbol,
       111551 /* Value */,
       /*enclosingDeclaration*/
       void 0,
@@ -160380,7 +160263,7 @@ registerCodeFix({
   },
   fixIds: [fixId26],
   getAllCodeActions: function getAllCodeActionsToFixClassDoesntImplementInheritedAbstractMember(context) {
-    const seenClassDeclarations = /* @__PURE__ */ new Map();
+    const seenClassDeclarations = /* @__PURE__ */ new Set();
     return codeFixAll(context, errorCodes32, (changes, diag2) => {
       const classDeclaration = getClass2(diag2.file, diag2.start);
       if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
@@ -160423,7 +160306,7 @@ registerCodeFix({
   fixIds: [fixId27],
   getAllCodeActions(context) {
     const { sourceFile } = context;
-    const seenClasses = /* @__PURE__ */ new Map();
+    const seenClasses = /* @__PURE__ */ new Set();
     return codeFixAll(context, errorCodes33, (changes, diag2) => {
       const nodes = getNodes(diag2.file, diag2.start);
       if (!nodes) return;
@@ -162367,7 +162250,7 @@ registerCodeFix({
   },
   fixIds: [fixId38],
   getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) {
-    const seen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     return codeFixAll(context, errorCodes49, (changes, diag2) => {
       const nodes = getNodes3(diag2.file, diag2.start);
       if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore))) return;
@@ -165233,7 +165116,7 @@ registerCodeFix({
   },
   getAllCodeActions: (context) => {
     const { program } = context;
-    const seen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
       eachDiagnostic(context, errorCodes65, (diag2) => {
         const info = getInfo21(diag2.file, diag2.start, program);
@@ -167672,7 +167555,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   let importSpecifierResolver;
   const symbolToOriginInfoMap = [];
   const symbolToSortTextMap = [];
-  const seenPropertySymbols = /* @__PURE__ */ new Map();
+  const seenPropertySymbols = /* @__PURE__ */ new Set();
   const isTypeOnlyLocation = isTypeOnlyCompletion();
   const getModuleSpecifierResolutionHost = memoizeOne((isFromPackageJson) => {
     return createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host);
@@ -169436,10 +169319,10 @@ function isArrowFunctionBody(node) {
   return node.parent && isArrowFunction(node.parent) && (node.parent.body === node || // const a = () => /**/;
   node.kind === 39 /* EqualsGreaterThanToken */);
 }
-function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules = /* @__PURE__ */ new Map()) {
+function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules = /* @__PURE__ */ new Set()) {
   return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(skipAlias(symbol.exportSymbol || symbol, checker));
   function nonAliasCanBeReferencedAtTypeLocation(symbol2) {
-    return !!(symbol2.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol2) || !!(symbol2.flags & 1536 /* Module */) && addToSeen(seenModules, getSymbolId(symbol2)) && checker.getExportsOfModule(symbol2).some((e) => symbolCanBeReferencedAtTypeLocation(e, checker, seenModules));
+    return !!(symbol2.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol2) || !!(symbol2.flags & 1536 /* Module */) && addToSeen(seenModules, symbol2) && checker.getExportsOfModule(symbol2).some((e) => symbolCanBeReferencedAtTypeLocation(e, checker, seenModules));
   }
 }
 function isDeprecated(symbol, checker) {
@@ -169511,7 +169394,7 @@ function createNameAndKindSet() {
 }
 function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences, includeSymbol) {
   if (isInReferenceComment(sourceFile, position)) {
-    const entries = getTripleSlashReferenceCompletion(sourceFile, position, program, host);
+    const entries = getTripleSlashReferenceCompletion(sourceFile, position, program, host, createModuleSpecifierResolutionHost(program, host));
     return entries && convertPathCompletions(entries);
   }
   if (isInString(sourceFile, position, contextToken)) {
@@ -169784,7 +169667,7 @@ function getAlreadyUsedTypesInStringLiteralUnion(union, current) {
 }
 function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) {
   let isNewIdentifier = false;
-  const uniques = /* @__PURE__ */ new Map();
+  const uniques = /* @__PURE__ */ new Set();
   const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg;
   const candidates = checker.getCandidateSignaturesForStringLiteralCompletions(call, editingArgument);
   const types = flatMap(candidates, (candidate) => {
@@ -169824,7 +169707,7 @@ function stringLiteralCompletionsForObjectLiteral(checker, objectLiteralExpressi
     hasIndexSignature: hasIndexSignature(contextualType)
   };
 }
-function getStringLiteralTypes(type, uniques = /* @__PURE__ */ new Map()) {
+function getStringLiteralTypes(type, uniques = /* @__PURE__ */ new Set()) {
   if (!type) return emptyArray;
   type = skipConstraint(type);
   return type.isUnion() ? flatMap(type.types, (t) => getStringLiteralTypes(t, uniques)) : type.isStringLiteral() && !(type.flags & 1024 /* EnumLiteral */) && addToSeen(uniques, type.value) ? [type] : emptyArray;
@@ -169855,8 +169738,9 @@ function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, prog
   const scriptDirectory = getDirectoryPath(scriptPath);
   const compilerOptions = program.getCompilerOptions();
   const typeChecker = program.getTypeChecker();
+  const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host);
   const extensionOptions = getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile, typeChecker, preferences, mode);
-  return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && !compilerOptions.paths && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, program, host, extensionOptions);
+  return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && !compilerOptions.paths && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, moduleSpecifierResolutionHost, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, program, host, moduleSpecifierResolutionHost, extensionOptions);
 }
 function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile, typeChecker, preferences, resolutionMode) {
   return {
@@ -169867,7 +169751,7 @@ function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile
     resolutionMode
   };
 }
-function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, scriptPath, extensionOptions) {
+function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, program, host, moduleSpecifierResolutionHost, scriptPath, extensionOptions) {
   const compilerOptions = program.getCompilerOptions();
   if (compilerOptions.rootDirs) {
     return getCompletionEntriesForDirectoryFragmentWithRootDirs(
@@ -169877,6 +169761,7 @@ function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, p
       extensionOptions,
       program,
       host,
+      moduleSpecifierResolutionHost,
       scriptPath
     );
   } else {
@@ -169886,6 +169771,7 @@ function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, p
       extensionOptions,
       program,
       host,
+      moduleSpecifierResolutionHost,
       /*moduleSpecifierIsRelative*/
       true,
       scriptPath
@@ -169911,7 +169797,7 @@ function getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ign
     compareStringsCaseSensitive
   );
 }
-function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, program, host, exclude) {
+function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, exclude) {
   const compilerOptions = program.getCompilerOptions();
   const basePath = compilerOptions.project || host.getCurrentDirectory();
   const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
@@ -169923,6 +169809,7 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment
       extensionOptions,
       program,
       host,
+      moduleSpecifierResolutionHost,
       /*moduleSpecifierIsRelative*/
       true,
       exclude
@@ -169930,7 +169817,7 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment
     (itemA, itemB) => itemA.name === itemB.name && itemA.kind === itemB.kind && itemA.extension === itemB.extension
   );
 }
-function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) {
+function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) {
   var _a;
   if (fragment === void 0) {
     fragment = "";
@@ -169955,7 +169842,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext
         if (versionPaths) {
           const packageDirectory = getDirectoryPath(packageJsonPath);
           const pathInPackage = absolutePath.slice(ensureTrailingDirectorySeparator(packageDirectory).length);
-          if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, program, host, versionPaths)) {
+          if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, versionPaths)) {
             return result;
           }
         }
@@ -169983,7 +169870,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext
         getBaseFileName(filePath),
         program,
         extensionOptions,
-        /*isExportsWildcard*/
+        /*isExportsOrImportsWildcard*/
         false
       );
       result.add(nameAndKind(name, "script" /* scriptElement */, extension));
@@ -170000,7 +169887,7 @@ function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, ext
   }
   return result;
 }
-function getFilenameWithExtensionOption(name, program, extensionOptions, isExportsWildcard) {
+function getFilenameWithExtensionOption(name, program, extensionOptions, isExportsOrImportsWildcard) {
   const nonJsResult = ts_moduleSpecifiers_exports.tryGetRealFileNameForNonJsDeclarationFileName(name);
   if (nonJsResult) {
     return { name: nonJsResult, extension: tryGetExtensionFromPath2(nonJsResult) };
@@ -170014,7 +169901,7 @@ function getFilenameWithExtensionOption(name, program, extensionOptions, isExpor
     program.getCompilerOptions(),
     extensionOptions.importingSourceFile
   ).getAllowedEndingsInPreferredOrder(extensionOptions.resolutionMode);
-  if (isExportsWildcard) {
+  if (isExportsOrImportsWildcard) {
     allowedEndings = allowedEndings.filter((e) => e !== 0 /* Minimal */ && e !== 1 /* Index */);
   }
   if (allowedEndings[0] === 3 /* TsExtension */) {
@@ -170024,13 +169911,13 @@ function getFilenameWithExtensionOption(name, program, extensionOptions, isExpor
     const outputExtension2 = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, program.getCompilerOptions());
     return outputExtension2 ? { name: changeExtension(name, outputExtension2), extension: outputExtension2 } : { name, extension: tryGetExtensionFromPath2(name) };
   }
-  if (!isExportsWildcard && (allowedEndings[0] === 0 /* Minimal */ || allowedEndings[0] === 1 /* Index */) && fileExtensionIsOneOf(name, [".js" /* Js */, ".jsx" /* Jsx */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */])) {
+  if (!isExportsOrImportsWildcard && (allowedEndings[0] === 0 /* Minimal */ || allowedEndings[0] === 1 /* Index */) && fileExtensionIsOneOf(name, [".js" /* Js */, ".jsx" /* Jsx */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */])) {
     return { name: removeFileExtension(name), extension: tryGetExtensionFromPath2(name) };
   }
   const outputExtension = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, program.getCompilerOptions());
   return outputExtension ? { name: changeExtension(name, outputExtension), extension: outputExtension } : { name, extension: tryGetExtensionFromPath2(name) };
 }
-function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, program, host, paths) {
+function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, paths) {
   const getPatternsForKey = (key) => paths[key];
   const comparePaths2 = (a, b) => {
     const patternA = tryParsePattern(a);
@@ -170039,40 +169926,43 @@ function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensio
     const lengthB = typeof patternB === "object" ? patternB.prefix.length : b.length;
     return compareValues(lengthB, lengthA);
   };
-  return addCompletionEntriesFromPathsOrExports(
+  return addCompletionEntriesFromPathsOrExportsOrImports(
     result,
     /*isExports*/
     false,
+    /*isImports*/
+    false,
     fragment,
     baseDirectory,
     extensionOptions,
     program,
     host,
+    moduleSpecifierResolutionHost,
     getOwnKeys(paths),
     getPatternsForKey,
     comparePaths2
   );
 }
-function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, baseDirectory, extensionOptions, program, host, keys, getPatternsForKey, comparePaths2) {
+function addCompletionEntriesFromPathsOrExportsOrImports(result, isExports, isImports, fragment, baseDirectory, extensionOptions, program, host, moduleSpecifierResolutionHost, keys, getPatternsForKey, comparePaths2) {
   let pathResults = [];
   let matchedPath;
   for (const key of keys) {
     if (key === ".") continue;
-    const keyWithoutLeadingDotSlash = key.replace(/^\.\//, "");
+    const keyWithoutLeadingDotSlash = key.replace(/^\.\//, "") + ((isExports || isImports) && endsWith(key, "/") ? "*" : "");
     const patterns = getPatternsForKey(key);
     if (patterns) {
       const pathPattern = tryParsePattern(keyWithoutLeadingDotSlash);
       if (!pathPattern) continue;
       const isMatch = typeof pathPattern === "object" && isPatternMatch(pathPattern, fragment);
-      const isLongestMatch = isMatch && (matchedPath === void 0 || comparePaths2(key, matchedPath) === -1 /* LessThan */);
+      const isLongestMatch = isMatch && (matchedPath === void 0 || comparePaths2(keyWithoutLeadingDotSlash, matchedPath) === -1 /* LessThan */);
       if (isLongestMatch) {
-        matchedPath = key;
+        matchedPath = keyWithoutLeadingDotSlash;
         pathResults = pathResults.filter((r) => !r.matchedPattern);
       }
-      if (typeof pathPattern === "string" || matchedPath === void 0 || comparePaths2(key, matchedPath) !== 1 /* GreaterThan */) {
+      if (typeof pathPattern === "string" || matchedPath === void 0 || comparePaths2(keyWithoutLeadingDotSlash, matchedPath) !== 1 /* GreaterThan */) {
         pathResults.push({
           matchedPattern: isMatch,
-          results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, isExports && isMatch, program, host).map(({ name, kind, extension }) => nameAndKind(name, kind, extension))
+          results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost).map(({ name, kind, extension }) => nameAndKind(name, kind, extension))
         });
       }
     }
@@ -170080,7 +169970,7 @@ function addCompletionEntriesFromPathsOrExports(result, isExports, fragment, bas
   pathResults.forEach((pathResult) => pathResult.results.forEach((r) => result.add(r)));
   return matchedPath !== void 0;
 }
-function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, program, host, extensionOptions) {
+function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, program, host, moduleSpecifierResolutionHost, extensionOptions) {
   const typeChecker = program.getTypeChecker();
   const compilerOptions = program.getCompilerOptions();
   const { baseUrl, paths } = compilerOptions;
@@ -170094,6 +169984,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p
       extensionOptions,
       program,
       host,
+      moduleSpecifierResolutionHost,
       /*moduleSpecifierIsRelative*/
       false,
       /*exclude*/
@@ -170103,7 +169994,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p
   }
   if (paths) {
     const absolute = getPathsBasePath(compilerOptions, host);
-    addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, program, host, paths);
+    addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, program, host, moduleSpecifierResolutionHost, paths);
   }
   const fragmentDirectory = getFragmentDirectory(fragment);
   for (const ambientName of getAmbientModuleCompletions(fragment, fragmentDirectory, typeChecker)) {
@@ -170114,7 +170005,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p
       void 0
     ));
   }
-  getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDirectory, extensionOptions, result);
+  getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, fragmentDirectory, extensionOptions, result);
   if (moduleResolutionUsesNodeModules(moduleResolution)) {
     let foundGlobal = false;
     if (fragmentDirectory === void 0) {
@@ -170132,6 +170023,26 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p
       }
     }
     if (!foundGlobal) {
+      const resolvePackageJsonExports = getResolvePackageJsonExports(compilerOptions);
+      const resolvePackageJsonImports = getResolvePackageJsonImports(compilerOptions);
+      let seenPackageScope = false;
+      const importsLookup = (directory) => {
+        if (resolvePackageJsonImports && !seenPackageScope) {
+          const packageFile = combinePaths(directory, "package.json");
+          if (seenPackageScope = tryFileExists(host, packageFile)) {
+            const packageJson = readJson(packageFile, host);
+            exportsOrImportsLookup(
+              packageJson.imports,
+              fragment,
+              directory,
+              /*isExports*/
+              false,
+              /*isImports*/
+              true
+            );
+          }
+        }
+      };
       let ancestorLookup = (ancestor) => {
         const nodeModules = combinePaths(ancestor, "node_modules");
         if (tryDirectoryExists(host, nodeModules)) {
@@ -170141,6 +170052,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p
             extensionOptions,
             program,
             host,
+            moduleSpecifierResolutionHost,
             /*moduleSpecifierIsRelative*/
             false,
             /*exclude*/
@@ -170148,58 +170060,77 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p
             result
           );
         }
+        importsLookup(ancestor);
       };
-      if (fragmentDirectory && getResolvePackageJsonExports(compilerOptions)) {
-        const nodeModulesDirectoryLookup = ancestorLookup;
+      if (fragmentDirectory && resolvePackageJsonExports) {
+        const nodeModulesDirectoryOrImportsLookup = ancestorLookup;
         ancestorLookup = (ancestor) => {
           const components = getPathComponents(fragment);
           components.shift();
           let packagePath = components.shift();
           if (!packagePath) {
-            return nodeModulesDirectoryLookup(ancestor);
+            return nodeModulesDirectoryOrImportsLookup(ancestor);
           }
           if (startsWith(packagePath, "@")) {
             const subName = components.shift();
             if (!subName) {
-              return nodeModulesDirectoryLookup(ancestor);
+              return nodeModulesDirectoryOrImportsLookup(ancestor);
             }
             packagePath = combinePaths(packagePath, subName);
           }
+          if (resolvePackageJsonImports && startsWith(packagePath, "#")) {
+            return importsLookup(ancestor);
+          }
           const packageDirectory = combinePaths(ancestor, "node_modules", packagePath);
           const packageFile = combinePaths(packageDirectory, "package.json");
           if (tryFileExists(host, packageFile)) {
             const packageJson = readJson(packageFile, host);
-            const exports2 = packageJson.exports;
-            if (exports2) {
-              if (typeof exports2 !== "object" || exports2 === null) {
-                return;
-              }
-              const keys = getOwnKeys(exports2);
-              const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : "");
-              const conditions = getConditions(compilerOptions, mode);
-              addCompletionEntriesFromPathsOrExports(
-                result,
-                /*isExports*/
-                true,
-                fragmentSubpath,
-                packageDirectory,
-                extensionOptions,
-                program,
-                host,
-                keys,
-                (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports2[key], conditions)),
-                comparePatternKeys
-              );
-              return;
-            }
+            const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : "");
+            exportsOrImportsLookup(
+              packageJson.exports,
+              fragmentSubpath,
+              packageDirectory,
+              /*isExports*/
+              true,
+              /*isImports*/
+              false
+            );
+            return;
           }
-          return nodeModulesDirectoryLookup(ancestor);
+          return nodeModulesDirectoryOrImportsLookup(ancestor);
         };
       }
       forEachAncestorDirectoryStoppingAtGlobalCache(host, scriptPath, ancestorLookup);
     }
   }
   return arrayFrom(result.values());
+  function exportsOrImportsLookup(lookupTable, fragment2, baseDirectory, isExports, isImports) {
+    if (typeof lookupTable !== "object" || lookupTable === null) {
+      return;
+    }
+    const keys = getOwnKeys(lookupTable);
+    const conditions = getConditions(compilerOptions, mode);
+    addCompletionEntriesFromPathsOrExportsOrImports(
+      result,
+      isExports,
+      isImports,
+      fragment2,
+      baseDirectory,
+      extensionOptions,
+      program,
+      host,
+      moduleSpecifierResolutionHost,
+      keys,
+      (key) => {
+        const pattern = getPatternFromFirstMatchingCondition(lookupTable[key], conditions);
+        if (pattern === void 0) {
+          return void 0;
+        }
+        return singleElementArray(endsWith(key, "/") && endsWith(pattern, "/") ? pattern + "*" : pattern);
+      },
+      comparePatternKeys
+    );
+  }
 }
 function getPatternFromFirstMatchingCondition(target, conditions) {
   if (typeof target === "string") {
@@ -170217,25 +170148,28 @@ function getPatternFromFirstMatchingCondition(target, conditions) {
 function getFragmentDirectory(fragment) {
   return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
 }
-function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, isExportsWildcard, program, host) {
-  if (!endsWith(path, "*")) {
-    return !path.includes("*") ? justPathMappingName(path, "script" /* scriptElement */) : emptyArray;
+function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost) {
+  const parsedPath = tryParsePattern(path);
+  if (!parsedPath) {
+    return emptyArray;
+  }
+  if (typeof parsedPath === "string") {
+    return justPathMappingName(path, "script" /* scriptElement */);
   }
-  const pathPrefix = path.slice(0, path.length - 1);
-  const remainingFragment = tryRemovePrefix(fragment, pathPrefix);
+  const remainingFragment = tryRemovePrefix(fragment, parsedPath.prefix);
   if (remainingFragment === void 0) {
-    const starIsFullPathComponent = path[path.length - 2] === "/";
-    return starIsFullPathComponent ? justPathMappingName(pathPrefix, "directory" /* directory */) : flatMap(patterns, (pattern) => {
+    const starIsFullPathComponent = endsWith(path, "/*");
+    return starIsFullPathComponent ? justPathMappingName(parsedPath.prefix, "directory" /* directory */) : flatMap(patterns, (pattern) => {
       var _a;
-      return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host)) == null ? void 0 : _a.map(({ name, ...rest }) => ({ name: pathPrefix + name, ...rest }));
+      return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost)) == null ? void 0 : _a.map(({ name, ...rest }) => ({ name: parsedPath.prefix + name + parsedPath.suffix, ...rest }));
     });
   }
-  return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host));
+  return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost));
   function justPathMappingName(name, kind) {
     return startsWith(name, fragment) ? [{ name: removeTrailingDirectorySeparator(name), kind, extension: void 0 }] : emptyArray;
   }
 }
-function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, isExportsWildcard, program, host) {
+function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, isExports, isImports, program, host, moduleSpecifierResolutionHost) {
   if (!host.readDirectory) {
     return void 0;
   }
@@ -170248,35 +170182,67 @@ function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensio
   const normalizedPrefixBase = hasTrailingDirectorySeparator(parsed.prefix) ? "" : getBaseFileName(normalizedPrefix);
   const fragmentHasPath = containsSlash(fragment);
   const fragmentDirectory = fragmentHasPath ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
+  const getCommonSourceDirectory2 = () => moduleSpecifierResolutionHost.getCommonSourceDirectory();
+  const ignoreCase = !hostUsesCaseSensitiveFileNames(moduleSpecifierResolutionHost);
+  const outDir = program.getCompilerOptions().outDir;
+  const declarationDir = program.getCompilerOptions().declarationDir;
   const expandedPrefixDirectory = fragmentHasPath ? combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + fragmentDirectory) : normalizedPrefixDirectory;
+  const baseDirectory = normalizePath(combinePaths(packageDirectory, expandedPrefixDirectory));
+  const possibleInputBaseDirectoryForOutDir = isImports && outDir && getPossibleOriginalInputPathWithoutChangingExt(baseDirectory, ignoreCase, outDir, getCommonSourceDirectory2);
+  const possibleInputBaseDirectoryForDeclarationDir = isImports && declarationDir && getPossibleOriginalInputPathWithoutChangingExt(baseDirectory, ignoreCase, declarationDir, getCommonSourceDirectory2);
   const normalizedSuffix = normalizePath(parsed.suffix);
   const declarationExtension = normalizedSuffix && getDeclarationEmitExtensionForPath("_" + normalizedSuffix);
-  const matchingSuffixes = declarationExtension ? [changeExtension(normalizedSuffix, declarationExtension), normalizedSuffix] : [normalizedSuffix];
-  const baseDirectory = normalizePath(combinePaths(packageDirectory, expandedPrefixDirectory));
-  const completePrefix = fragmentHasPath ? baseDirectory : ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase;
+  const inputExtension = normalizedSuffix ? getPossibleOriginalInputExtensionForExtension("_" + normalizedSuffix) : void 0;
+  const matchingSuffixes = [
+    declarationExtension && changeExtension(normalizedSuffix, declarationExtension),
+    ...inputExtension ? inputExtension.map((ext) => changeExtension(normalizedSuffix, ext)) : [],
+    normalizedSuffix
+  ].filter(isString);
   const includeGlobs = normalizedSuffix ? matchingSuffixes.map((suffix) => "**/*" + suffix) : ["./*"];
-  const matches = mapDefined(tryReadDirectory(
-    host,
-    baseDirectory,
-    extensionOptions.extensionsToSearch,
-    /*exclude*/
-    void 0,
-    includeGlobs
-  ), (match) => {
-    const trimmedWithPattern = trimPrefixAndSuffix(match);
-    if (trimmedWithPattern) {
-      if (containsSlash(trimmedWithPattern)) {
-        return directoryResult(getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]);
-      }
-      const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, program, extensionOptions, isExportsWildcard);
-      return nameAndKind(name, "script" /* scriptElement */, extension);
+  const isExportsOrImportsWildcard = (isExports || isImports) && endsWith(pattern, "/*");
+  let matches = getMatchesWithPrefix(baseDirectory);
+  if (possibleInputBaseDirectoryForOutDir) {
+    matches = concatenate(matches, getMatchesWithPrefix(possibleInputBaseDirectoryForOutDir));
+  }
+  if (possibleInputBaseDirectoryForDeclarationDir) {
+    matches = concatenate(matches, getMatchesWithPrefix(possibleInputBaseDirectoryForDeclarationDir));
+  }
+  if (!normalizedSuffix) {
+    matches = concatenate(matches, getDirectoryMatches(baseDirectory));
+    if (possibleInputBaseDirectoryForOutDir) {
+      matches = concatenate(matches, getDirectoryMatches(possibleInputBaseDirectoryForOutDir));
     }
-  });
-  const directories = normalizedSuffix ? emptyArray : mapDefined(tryGetDirectories(host, baseDirectory), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir));
-  return [...matches, ...directories];
-  function trimPrefixAndSuffix(path) {
+    if (possibleInputBaseDirectoryForDeclarationDir) {
+      matches = concatenate(matches, getDirectoryMatches(possibleInputBaseDirectoryForDeclarationDir));
+    }
+  }
+  return matches;
+  function getMatchesWithPrefix(directory) {
+    const completePrefix = fragmentHasPath ? directory : ensureTrailingDirectorySeparator(directory) + normalizedPrefixBase;
+    return mapDefined(tryReadDirectory(
+      host,
+      directory,
+      extensionOptions.extensionsToSearch,
+      /*exclude*/
+      void 0,
+      includeGlobs
+    ), (match) => {
+      const trimmedWithPattern = trimPrefixAndSuffix(match, completePrefix);
+      if (trimmedWithPattern) {
+        if (containsSlash(trimmedWithPattern)) {
+          return directoryResult(getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]);
+        }
+        const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, program, extensionOptions, isExportsOrImportsWildcard);
+        return nameAndKind(name, "script" /* scriptElement */, extension);
+      }
+    });
+  }
+  function getDirectoryMatches(directoryName) {
+    return mapDefined(tryGetDirectories(host, directoryName), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir));
+  }
+  function trimPrefixAndSuffix(path, prefix) {
     return firstDefined(matchingSuffixes, (suffix) => {
-      const inner = withoutStartAndEnd(normalizePath(path), completePrefix, suffix);
+      const inner = withoutStartAndEnd(normalizePath(path), prefix, suffix);
       return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner);
     });
   }
@@ -170296,7 +170262,7 @@ function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
   }
   return nonRelativeModuleNames;
 }
-function getTripleSlashReferenceCompletion(sourceFile, position, program, host) {
+function getTripleSlashReferenceCompletion(sourceFile, position, program, host, moduleSpecifierResolutionHost) {
   const compilerOptions = program.getCompilerOptions();
   const token = getTokenAtPosition(sourceFile, position);
   const commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos);
@@ -170317,13 +170283,14 @@ function getTripleSlashReferenceCompletion(sourceFile, position, program, host)
     getExtensionOptions(compilerOptions, 0 /* Filename */, sourceFile),
     program,
     host,
+    moduleSpecifierResolutionHost,
     /*moduleSpecifierIsRelative*/
     true,
     sourceFile.path
-  ) : kind === "types" ? getCompletionEntriesFromTypings(host, program, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile)) : Debug.fail();
+  ) : kind === "types" ? getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile)) : Debug.fail();
   return addReplacementSpans(toComplete, range.pos + prefix.length, arrayFrom(names.values()));
 }
-function getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
+function getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
   const options = program.getCompilerOptions();
   const seen = /* @__PURE__ */ new Map();
   const typeRoots = tryAndIgnoreErrors(() => getEffectiveTypeRoots(options, host)) || emptyArray;
@@ -170360,6 +170327,7 @@ function getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDire
             extensionOptions,
             program,
             host,
+            moduleSpecifierResolutionHost,
             /*moduleSpecifierIsRelative*/
             false,
             /*exclude*/
@@ -171112,7 +171080,7 @@ function getImplementationsAtPosition(program, cancellationToken, sourceFiles, s
     referenceEntries = entries && [...entries];
   } else if (entries) {
     const queue = createQueue(entries);
-    const seenNodes = /* @__PURE__ */ new Map();
+    const seenNodes = /* @__PURE__ */ new Set();
     while (!queue.isEmpty()) {
       const entry = queue.dequeue();
       if (!addToSeen(seenNodes, getNodeId(entry.node))) {
@@ -172764,10 +172732,10 @@ var Core;
     }
   }
   function getPropertySymbolsFromBaseTypes(symbol, propertyName, checker, cb) {
-    const seen = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     return recur(symbol);
     function recur(symbol2) {
-      if (!(symbol2.flags & (32 /* Class */ | 64 /* Interface */)) || !addToSeen(seen, getSymbolId(symbol2))) return;
+      if (!(symbol2.flags & (32 /* Class */ | 64 /* Interface */)) || !addToSeen(seen, symbol2)) return;
       return firstDefined(symbol2.declarations, (declaration) => firstDefined(getAllSuperTypeNodes(declaration), (typeReference) => {
         const type = checker.getTypeAtLocation(typeReference);
         const propertySymbol = type && type.symbol && checker.getPropertyOfType(type, propertyName);
@@ -173553,11 +173521,8 @@ function provideInlayHints(context) {
     if (!args || !args.length) {
       return;
     }
-    const candidates = [];
-    const signature = checker.getResolvedSignatureForSignatureHelp(expr, candidates);
-    if (!signature || !candidates.length) {
-      return;
-    }
+    const signature = checker.getResolvedSignature(expr);
+    if (signature === void 0) return;
     let signatureParamPos = 0;
     for (const originalArg of args) {
       const arg = skipParentheses(originalArg);
@@ -177415,6 +177380,7 @@ __export(ts_textChanges_exports, {
   assignPositionsToNode: () => assignPositionsToNode,
   createWriter: () => createWriter,
   deleteNode: () => deleteNode,
+  getAdjustedEndPosition: () => getAdjustedEndPosition,
   isThisTypeAnnotatable: () => isThisTypeAnnotatable,
   isValidLocationToAddComment: () => isValidLocationToAddComment
 });
@@ -177914,7 +177880,10 @@ var ChangeTracker = class _ChangeTracker {
   getInsertNodeAtStartInsertOptions(sourceFile, node, indentation) {
     const members = getMembersOrProperties(node);
     const isEmpty = members.length === 0;
-    const isFirstInsertion = addToSeen(this.classesWithNodesInsertedAtStart, getNodeId(node), { node, sourceFile });
+    const isFirstInsertion = !this.classesWithNodesInsertedAtStart.has(getNodeId(node));
+    if (isFirstInsertion) {
+      this.classesWithNodesInsertedAtStart.set(getNodeId(node), { node, sourceFile });
+    }
     const insertTrailingComma = isObjectLiteralExpression(node) && (!isJsonSourceFile(sourceFile) || !isEmpty);
     const insertLeadingComma = isObjectLiteralExpression(node) && isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion;
     return {
@@ -179824,6 +179793,9 @@ function isSemicolonDeletionContext(context) {
   if (startLine === endLine) {
     return nextTokenKind === 20 /* CloseBraceToken */ || nextTokenKind === 1 /* EndOfFileToken */;
   }
+  if (nextTokenKind === 27 /* SemicolonToken */ && context.currentTokenSpan.kind === 27 /* SemicolonToken */) {
+    return true;
+  }
   if (nextTokenKind === 240 /* SemicolonClassElement */ || nextTokenKind === 27 /* SemicolonToken */) {
     return false;
   }
@@ -181569,11 +181541,13 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr
         }
         statements.push(...statementsInSourceFile.slice(startNodeIndex, endNodeIndex === -1 ? statementsInSourceFile.length : endNodeIndex + 1));
       });
-      const usage = getUsageInfo(copiedFrom.file, statements, originalProgram.getTypeChecker(), getExistingLocals(updatedFile, statements, originalProgram.getTypeChecker()), { pos: copiedFrom.range[0].pos, end: copiedFrom.range[copiedFrom.range.length - 1].end });
-      Debug.assertIsDefined(originalProgram);
+      Debug.assertIsDefined(originalProgram, "no original program found");
+      const originalProgramTypeChecker = originalProgram.getTypeChecker();
+      const usageInfoRange = getUsageInfoRangeForPasteEdits(copiedFrom);
+      const usage = getUsageInfo(copiedFrom.file, statements, originalProgramTypeChecker, getExistingLocals(updatedFile, statements, originalProgramTypeChecker), usageInfoRange);
       const useEsModuleSyntax = !fileShouldUseJavaScriptRequire(targetFile.fileName, originalProgram, host, !!copiedFrom.file.commonJsModuleIndicator);
       addExportsInOldFile(copiedFrom.file, usage.targetFileImportsFromOldFile, changes, useEsModuleSyntax);
-      addTargetFileImports(copiedFrom.file, usage.oldImportsNeededByTargetFile, usage.targetFileImportsFromOldFile, originalProgram.getTypeChecker(), updatedProgram, importAdder);
+      addTargetFileImports(copiedFrom.file, usage.oldImportsNeededByTargetFile, usage.targetFileImportsFromOldFile, originalProgramTypeChecker, updatedProgram, importAdder);
     } else {
       const context = {
         sourceFile: updatedFile,
@@ -181629,6 +181603,16 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr
     );
   });
 }
+function getUsageInfoRangeForPasteEdits({ file: sourceFile, range }) {
+  const pos = range[0].pos;
+  const end = range[range.length - 1].end;
+  const startToken = getTokenAtPosition(sourceFile, pos);
+  const endToken = findTokenOnLeftOfPosition(sourceFile, pos) ?? getTokenAtPosition(sourceFile, end);
+  return {
+    pos: isIdentifier(startToken) && pos <= startToken.getStart(sourceFile) ? startToken.getFullStart() : pos,
+    end: isIdentifier(endToken) && end === endToken.getEnd() ? ts_textChanges_exports.getAdjustedEndPosition(sourceFile, endToken, {}) : end
+  };
+}
 
 // src/server/_namespaces/ts.ts
 var ts_exports2 = {};
@@ -182542,6 +182526,7 @@ __export(ts_exports2, {
   getPositionOfLineAndCharacter: () => getPositionOfLineAndCharacter,
   getPossibleGenericSignatures: () => getPossibleGenericSignatures,
   getPossibleOriginalInputExtensionForExtension: () => getPossibleOriginalInputExtensionForExtension,
+  getPossibleOriginalInputPathWithoutChangingExt: () => getPossibleOriginalInputPathWithoutChangingExt,
   getPossibleTypeArgumentsInfo: () => getPossibleTypeArgumentsInfo,
   getPreEmitDiagnostics: () => getPreEmitDiagnostics,
   getPrecedingNonSpaceCharacterPosition: () => getPrecedingNonSpaceCharacterPosition,
@@ -188300,7 +188285,7 @@ var _ProjectService = class _ProjectService {
      */
     this.filenameToScriptInfoVersion = /* @__PURE__ */ new Map();
     // Set of all '.js' files ever opened.
-    this.allJsFilesForOpenFileTelemetry = /* @__PURE__ */ new Map();
+    this.allJsFilesForOpenFileTelemetry = /* @__PURE__ */ new Set();
     /**
      * maps external project file name to list of config files that were the part of this project
      */
@@ -195882,6 +195867,7 @@ var LineNode = class _LineNode {
     }
   }
   walk(rangeStart, rangeLength, walkFns) {
+    if (this.children.length === 0) return;
     let childIndex = 0;
     let childCharCount = this.children[childIndex].charCount();
     let adjustedStart = rangeStart;
@@ -197286,6 +197272,7 @@ if (typeof console !== "undefined") {
   getPositionOfLineAndCharacter,
   getPossibleGenericSignatures,
   getPossibleOriginalInputExtensionForExtension,
+  getPossibleOriginalInputPathWithoutChangingExt,
   getPossibleTypeArgumentsInfo,
   getPreEmitDiagnostics,
   getPrecedingNonSpaceCharacterPosition,