typescript 5.0.0-dev.20230110 → 5.0.0-dev.20230112

package/lib/typescript.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230110`;
+      version = `${versionMajorMinor}.0-dev.20230112`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -8023,6 +8023,7 @@ ${lanes.join("\n")}
         Default_export_of_the_module_has_or_is_using_private_name_0: diag(4082, 1 /* Error */, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."),
         Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: diag(4083, 1 /* Error */, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."),
         Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2: diag(4084, 1 /* Error */, "Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2_4084", "Exported type alias '{0}' has or is using private name '{1}' from module {2}."),
+        Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1: diag(4085, 1 /* Error */, "Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1_4085", "Extends clause for inferred type '{0}' has or is using private name '{1}'."),
         Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict: diag(4090, 1 /* Error */, "Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_librar_4090", "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict."),
         Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4091, 1 /* Error */, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."),
         Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4092, 1 /* Error */, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."),
@@ -9526,7 +9527,8 @@ ${lanes.join("\n")}
     return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
   }
   function isIdentifierPart(ch, languageVersion, identifierVariant) {
-    return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
+    return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || // "-" and ":" are valid in JSX Identifiers
+    (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
   }
   function isIdentifierText(name, languageVersion, identifierVariant) {
     let ch = codePointAt(name, 0);
@@ -18397,6 +18399,10 @@ ${lanes.join("\n")}
         return false;
     }
   }
+  function isNonNullAccess(node) {
+    const kind = node.kind;
+    return (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */) && isNonNullExpression(node.expression);
+  }
   var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashAMDReferencePathRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, AccessKind, objectAllocator, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
@@ -34986,7 +34992,8 @@ ${lanes.join("\n")}
           if (returnValue) {
             result[keyText] = value;
           }
-          if (jsonConversionNotifier && (parentOption || isRootOptionMap(knownOptions))) {
+          if (jsonConversionNotifier && // Current callbacks are only on known parent option or if we are setting values in the root
+          (parentOption || isRootOptionMap(knownOptions))) {
             const isValidOptionValue = isCompilerOptionsValue(option, value);
             if (parentOption) {
               if (isValidOptionValue) {
@@ -38031,7 +38038,8 @@ ${lanes.join("\n")}
       conditions,
       requestContainingDirectory: containingDirectory,
       reportDiagnostic: (diag2) => void diagnostics.push(diag2),
-      isConfigLookup: false
+      isConfigLookup: false,
+      candidateIsFromPackageJsonField: false
     };
     let resolved = primaryLookup();
     let primary = true;
@@ -38889,7 +38897,8 @@ ${lanes.join("\n")}
       conditions,
       requestContainingDirectory: containingDirectory,
       reportDiagnostic: (diag2) => void diagnostics.push(diag2),
-      isConfigLookup
+      isConfigLookup,
+      candidateIsFromPackageJsonField: false
     };
     if (traceEnabled && getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) <= 99 /* NodeNext */) {
       trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & 32 /* EsmMode */ ? "ESM" : "CJS", conditions.map((c) => `'${c}'`).join(", "));
@@ -39112,7 +39121,7 @@ ${lanes.join("\n")}
     }
     function tryExtension(ext, resolvedUsingTsExtension) {
       const path = tryFile(candidate + ext, onlyRecordFailures, state);
-      return path === void 0 ? void 0 : { path, ext, resolvedUsingTsExtension };
+      return path === void 0 ? void 0 : { path, ext, resolvedUsingTsExtension: !state.candidateIsFromPackageJsonField && resolvedUsingTsExtension };
     }
   }
   function tryFile(fileName, onlyRecordFailures, state) {
@@ -39259,7 +39268,8 @@ ${lanes.join("\n")}
       conditions: emptyArray,
       requestContainingDirectory: void 0,
       reportDiagnostic: noop,
-      isConfigLookup: false
+      isConfigLookup: false,
+      candidateIsFromPackageJsonField: false
     };
   }
   function getPackageScopeForPath(fileName, state) {
@@ -39347,6 +39357,8 @@ ${lanes.join("\n")}
       }
       const expandedExtensions = extensions2 === 4 /* Declaration */ ? 1 /* TypeScript */ | 4 /* Declaration */ : extensions2;
       const features = state2.features;
+      const candidateIsFromPackageJsonField = state2.candidateIsFromPackageJsonField;
+      state2.candidateIsFromPackageJsonField = true;
       if ((jsonContent == null ? void 0 : jsonContent.type) !== "module") {
         state2.features &= ~32 /* EsmMode */;
       }
@@ -39359,6 +39371,7 @@ ${lanes.join("\n")}
         false
       );
       state2.features = features;
+      state2.candidateIsFromPackageJsonField = candidateIsFromPackageJsonField;
       return result;
     };
     const onlyRecordFailuresForPackageFile = packageFile ? !directoryProbablyExists(getDirectoryPath(packageFile), state.host) : void 0;
@@ -39432,7 +39445,10 @@ ${lanes.join("\n")}
       return void 0;
     }
     const trailingParts = parts.slice(nameParts.length);
-    return loadModuleFromExports(scope, extensions, !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`, state, cache, redirectedReference);
+    const subpath = !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`;
+    const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
+    const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
+    return loadModuleFromExports(scope, priorityExtensions, subpath, state, cache, redirectedReference) || loadModuleFromExports(scope, secondaryExtensions, subpath, state, cache, redirectedReference);
   }
   function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) {
     if (!scope.contents.packageJsonContent.exports) {
@@ -39934,25 +39950,26 @@ ${lanes.join("\n")}
     }
   }
   function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
-    var _a2;
+    var _a2, _b, _c;
     const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName));
+    const { packageName, rest } = parsePackageName(moduleName);
+    const packageDirectory = combinePaths(nodeModulesDirectory, packageName);
+    let rootPackageInfo;
     let packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
-    if (!(state.features & 8 /* Exports */)) {
-      if (packageInfo) {
-        const fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
-        if (fromFile) {
-          return noPackageId(fromFile);
-        }
-        const fromDirectory = loadNodeModuleFromDirectoryWorker(
-          extensions,
-          candidate,
-          !nodeModulesDirectoryExists,
-          state,
-          packageInfo.contents.packageJsonContent,
-          getVersionPathsOfPackageJsonInfo(packageInfo, state)
-        );
-        return withPackageId(packageInfo, fromDirectory);
+    if (rest !== "" && packageInfo && (!(state.features & 8 /* Exports */) || !hasProperty((_b = (_a2 = rootPackageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state)) == null ? void 0 : _a2.contents.packageJsonContent) != null ? _b : emptyArray, "exports"))) {
+      const fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
+      if (fromFile) {
+        return noPackageId(fromFile);
       }
+      const fromDirectory = loadNodeModuleFromDirectoryWorker(
+        extensions,
+        candidate,
+        !nodeModulesDirectoryExists,
+        state,
+        packageInfo.contents.packageJsonContent,
+        getVersionPathsOfPackageJsonInfo(packageInfo, state)
+      );
+      return withPackageId(packageInfo, fromDirectory);
     }
     const loader = (extensions2, candidate2, onlyRecordFailures, state2) => {
       let pathAndExtension = loadModuleFromFile(extensions2, candidate2, onlyRecordFailures, state2) || loadNodeModuleFromDirectoryWorker(
@@ -39968,13 +39985,11 @@ ${lanes.join("\n")}
       }
       return withPackageId(packageInfo, pathAndExtension);
     };
-    const { packageName, rest } = parsePackageName(moduleName);
-    const packageDirectory = combinePaths(nodeModulesDirectory, packageName);
     if (rest !== "") {
-      packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
+      packageInfo = rootPackageInfo != null ? rootPackageInfo : getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
     }
     if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & 8 /* Exports */) {
-      return (_a2 = loadModuleFromExports(packageInfo, extensions, combinePaths(".", rest), state, cache, redirectedReference)) == null ? void 0 : _a2.value;
+      return (_c = loadModuleFromExports(packageInfo, extensions, combinePaths(".", rest), state, cache, redirectedReference)) == null ? void 0 : _c.value;
     }
     const versionPaths = rest !== "" && packageInfo ? getVersionPathsOfPackageJsonInfo(packageInfo, state) : void 0;
     if (versionPaths) {
@@ -40090,7 +40105,8 @@ ${lanes.join("\n")}
       conditions: [],
       requestContainingDirectory: containingDirectory,
       reportDiagnostic: (diag2) => void diagnostics.push(diag2),
-      isConfigLookup: false
+      isConfigLookup: false,
+      candidateIsFromPackageJsonField: false
     };
     const resolved = tryResolve(1 /* TypeScript */ | 4 /* Declaration */) || tryResolve(2 /* JavaScript */ | (compilerOptions.resolveJsonModule ? 8 /* Json */ : 0));
     return createResolvedModuleWithFailedLookupLocations(
@@ -40169,7 +40185,8 @@ ${lanes.join("\n")}
       conditions: [],
       requestContainingDirectory: void 0,
       reportDiagnostic: (diag2) => void diagnostics.push(diag2),
-      isConfigLookup: false
+      isConfigLookup: false,
+      candidateIsFromPackageJsonField: false
     };
     const resolved = loadModuleFromImmediateNodeModulesDirectory(
       4 /* Declaration */,
@@ -42952,8 +42969,12 @@ ${lanes.join("\n")}
         return false;
       }
       if (currentFlow === unreachableFlow) {
-        const reportError = isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || // report error on class declarations
-        node.kind === 260 /* ClassDeclaration */ || node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node);
+        const reportError = (
+          // report error on all statements except empty ones
+          isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || // report error on class declarations
+          node.kind === 260 /* ClassDeclaration */ || // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+          node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)
+        );
         if (reportError) {
           currentFlow = reportedUnreachableFlow;
           if (!options.allowUnreachableCode) {
@@ -48716,7 +48737,8 @@ ${lanes.join("\n")}
             const isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || // is exported function symbol
             forEach(symbol.declarations, (declaration) => declaration.parent.kind === 308 /* SourceFile */ || declaration.parent.kind === 265 /* ModuleBlock */));
             if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
-              return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a4 = context.visitedTypes) == null ? void 0 : _a4.has(typeId))) && (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
+              return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a4 = context.visitedTypes) == null ? void 0 : _a4.has(typeId))) && // it is type of the symbol uses itself recursively
+              (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
             }
           }
         }
@@ -48808,7 +48830,9 @@ ${lanes.join("\n")}
           const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
           if (some(abstractSignatures)) {
             const types = map(abstractSignatures, getOrCreateTypeFromSignature);
-            const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
+            const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
+            // the logic in `createTypeNodesFromResolvedType`.
+            (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
             if (typeElementCount) {
               types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved));
             }
@@ -49470,9 +49494,11 @@ ${lanes.join("\n")}
           if (accessibleSymbolChain) {
             return accessibleSymbolChain;
           }
-          if (// If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
-          endOfChain || // If a parent symbol is an anonymous type, don't write it.
-          !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))) {
+          if (
+            // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
+            endOfChain || // If a parent symbol is an anonymous type, don't write it.
+            !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))
+          ) {
             if (!endOfChain && !yieldModuleSymbol && !!forEach(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
               return;
             }
@@ -50094,7 +50120,8 @@ ${lanes.join("\n")}
           }
           if (isLiteralImportTypeNode(node)) {
             const nodeSymbol = getNodeLinks(node).resolvedSymbol;
-            if (isInJSDoc(node) && nodeSymbol && (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
+            if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic
+            (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
             !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
               return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
             }
@@ -51611,8 +51638,10 @@ ${lanes.join("\n")}
       }
     }
     function getNameOfSymbolAsWritten(symbol, context) {
-      if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && (!(context.flags & 16777216 /* InInitialEntityName */) || // if the symbol is synthesized, it will only be referenced externally it must print as `default`
-      !symbol.declarations || context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
+      if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && // If it's not the first part of an entity name, it must print as `default`
+      (!(context.flags & 16777216 /* InInitialEntityName */) || // if the symbol is synthesized, it will only be referenced externally it must print as `default`
+      !symbol.declarations || // if not in the same binding context (source file, module declaration), it must print as `default`
+      context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
         return "default";
       }
       if (symbol.declarations && symbol.declarations.length) {
@@ -52939,7 +52968,10 @@ ${lanes.join("\n")}
     function getWriteTypeOfSymbol(symbol) {
       const checkFlags = getCheckFlags(symbol);
       if (symbol.flags & 4 /* Property */) {
-        return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : symbol.links.writeType || symbol.links.type : getTypeOfSymbol(symbol);
+        return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : (
+          // NOTE: cast to TransientSymbol should be safe because only TransientSymbols can have CheckFlags.SyntheticProperty
+          symbol.links.writeType || symbol.links.type
+        ) : getTypeOfSymbol(symbol);
       }
       if (symbol.flags & 98304 /* Accessor */) {
         return checkFlags & 1 /* Instantiated */ ? getWriteTypeOfInstantiatedSymbol(symbol) : getWriteTypeOfAccessors(symbol);
@@ -53064,7 +53096,17 @@ ${lanes.join("\n")}
       }
     }
     function getOuterTypeParametersOfClassOrInterface(symbol) {
-      const declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : getDeclarationOfKind(symbol, 261 /* InterfaceDeclaration */);
+      var _a2;
+      const declaration = symbol.flags & 32 /* Class */ || symbol.flags & 16 /* Function */ ? symbol.valueDeclaration : (_a2 = symbol.declarations) == null ? void 0 : _a2.find((decl) => {
+        if (decl.kind === 261 /* InterfaceDeclaration */) {
+          return true;
+        }
+        if (decl.kind !== 257 /* VariableDeclaration */) {
+          return false;
+        }
+        const initializer = decl.initializer;
+        return !!initializer && (initializer.kind === 215 /* FunctionExpression */ || initializer.kind === 216 /* ArrowFunction */);
+      });
       Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations");
       return getOuterTypeParameters(declaration);
     }
@@ -61346,7 +61388,11 @@ ${lanes.join("\n")}
           if (variances === emptyArray) {
             return 1 /* Unknown */;
           }
-          const varianceResult = relateVariances(source2.aliasTypeArguments, target2.aliasTypeArguments, variances, intersectionState);
+          const params = getSymbolLinks(source2.aliasSymbol).typeParameters;
+          const minParams = getMinTypeArgumentCount(params);
+          const sourceTypes = fillMissingTypeArguments(source2.aliasTypeArguments, params, minParams, isInJSFile(source2.aliasSymbol.valueDeclaration));
+          const targetTypes = fillMissingTypeArguments(target2.aliasTypeArguments, params, minParams, isInJSFile(source2.aliasSymbol.valueDeclaration));
+          const varianceResult = relateVariances(sourceTypes, targetTypes, variances, intersectionState);
           if (varianceResult !== void 0) {
             return varianceResult;
           }
@@ -63803,7 +63849,11 @@ ${lanes.join("\n")}
         }
         if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
           if (source.aliasTypeArguments) {
-            inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
+            const params = getSymbolLinks(source.aliasSymbol).typeParameters;
+            const minParams = getMinTypeArgumentCount(params);
+            const sourceTypes = fillMissingTypeArguments(source.aliasTypeArguments, params, minParams, isInJSFile(source.aliasSymbol.valueDeclaration));
+            const targetTypes = fillMissingTypeArguments(target.aliasTypeArguments, params, minParams, isInJSFile(source.aliasSymbol.valueDeclaration));
+            inferFromTypeArguments(sourceTypes, targetTypes, getAliasVariances(source.aliasSymbol));
           }
           return;
         }
@@ -64409,7 +64459,7 @@ ${lanes.join("\n")}
         if (signature) {
           const inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : void 0;
           if (inference.contraCandidates) {
-            const useCovariantType = inferredCovariantType && !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) && every(context.inferences, (other) => other === inference || getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType)));
+            const useCovariantType = inferredCovariantType && !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) && every(context.inferences, (other) => other !== inference && getConstraintOfTypeParameter(other.typeParameter) !== inference.typeParameter || every(other.candidates, (t) => isTypeSubtypeOf(t, inferredCovariantType)));
             inferredType = useCovariantType ? inferredCovariantType : getContravariantInference(inference);
           } else if (inferredCovariantType) {
             inferredType = inferredCovariantType;
@@ -65885,12 +65935,13 @@ ${lanes.join("\n")}
         if (propName === void 0) {
           return type;
         }
-        const removeNullable = strictNullChecks && isOptionalChain(access) && maybeTypeOfKind(type, 98304 /* Nullable */);
+        const optionalChain = isOptionalChain(access);
+        const removeNullable = strictNullChecks && (optionalChain || isNonNullAccess(access)) && maybeTypeOfKind(type, 98304 /* Nullable */);
         let propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type, propName);
         if (!propType) {
           return type;
         }
-        propType = removeNullable ? getOptionalType(propType) : propType;
+        propType = removeNullable && optionalChain ? getOptionalType(propType) : propType;
         const narrowedPropType = narrowType2(propType);
         return filterType(type, (t) => {
           const discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
@@ -66209,18 +66260,20 @@ ${lanes.join("\n")}
         return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeofEQHostObject */);
       }
       function narrowTypeByTypeFacts(type, impliedType, facts) {
-        return mapType(type, (t) => // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
-        // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
-        // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
-        // but are classified as "function" according to `typeof`.
-        isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
-          // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
-          // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
-          isTypeSubtypeOf(impliedType, t) ? impliedType : (
-            // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
-            // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
-            // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
-            getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+        return mapType(type, (t) => (
+          // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
+          // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
+          // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
+          // but are classified as "function" according to `typeof`.
+          isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
+            // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
+            // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
+            isTypeSubtypeOf(impliedType, t) ? impliedType : (
+              // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
+              // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
+              // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
+              getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+            )
           )
         ));
       }
@@ -73791,7 +73844,8 @@ ${lanes.join("\n")}
         }
       }
       function isIndirectCall(node) {
-        return node.parent.kind === 214 /* ParenthesizedExpression */ && isNumericLiteral(node.left) && node.left.text === "0" && (isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent || node.parent.parent.kind === 212 /* TaggedTemplateExpression */) && (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
+        return node.parent.kind === 214 /* ParenthesizedExpression */ && isNumericLiteral(node.left) && node.left.text === "0" && (isCallExpression(node.parent.parent) && node.parent.parent.expression === node.parent || node.parent.parent.kind === 212 /* TaggedTemplateExpression */) && // special-case for "eval" because it's the only non-access case where an indirect call actually affects behavior.
+        (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
       }
       function checkForDisallowedESSymbolOperand(operator2) {
         const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right : void 0;
@@ -80876,7 +80930,12 @@ ${lanes.join("\n")}
           return false;
         const symbol = getSymbolOfDeclaration(node);
         const signaturesOfSymbol = getSignaturesOfSymbol(symbol);
-        return signaturesOfSymbol.length > 1 || signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
+        return signaturesOfSymbol.length > 1 || // If there is single signature for the symbol, it is overload if that signature isn't coming from the node
+        // e.g.: function foo(a: string): string;
+        //       function foo(a: any) { // This is implementation of the overloads
+        //           return a;
+        //       }
+        signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
       }
       return false;
     }
@@ -102777,6 +102836,9 @@ ${lanes.join("\n")}
         case 259 /* FunctionDeclaration */:
           diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
           break;
+        case 192 /* InferType */:
+          diagnosticMessage = Diagnostics.Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1;
+          break;
         case 262 /* TypeAliasDeclaration */:
           diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1;
           break;
@@ -111731,7 +111793,8 @@ ${lanes.join("\n")}
       const oldSourceFiles = oldProgram.getSourceFiles();
       for (const oldSourceFile of oldSourceFiles) {
         const newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
-        if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
+        if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || // old file wasn't redirect but new file is
+        oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
           host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
         }
       }
@@ -116617,7 +116680,8 @@ ${lanes.join("\n")}
         const name = loader.nameAndMode.getName(entry);
         const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
         let resolution = resolutionsInFile.get(name, mode);
-        if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
+        if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || // If the name is unresolved import that was invalidated, recalculate
+        hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
           const existingResolution = resolution;
           resolution = loader.resolve(name, mode);
           if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
@@ -122290,7 +122354,11 @@ ${lanes.join("\n")}
         return n;
       }
       return firstDefined(n.getChildren(sourceFile), (child) => {
-        const shouldDiveInChildNode = child.pos <= previousToken.pos && child.end > previousToken.end || child.pos === previousToken.end;
+        const shouldDiveInChildNode = (
+          // previous token is enclosed somewhere in the child
+          child.pos <= previousToken.pos && child.end > previousToken.end || // previous token ends exactly at the beginning of child
+          child.pos === previousToken.end
+        );
         return shouldDiveInChildNode && nodeHasTokens(child, sourceFile) ? find2(child) : void 0;
       });
     }
@@ -135961,15 +136029,17 @@ ${lanes.join("\n")}
       return fixes[0];
     }
     return fixes.reduce(
-      (best, fix) => // Takes true branch of conditional if `fix` is better than `best`
-      compareModuleSpecifiers(
-        fix,
-        best,
-        sourceFile,
-        program,
-        packageJsonImportFilter.allowsImportingSpecifier,
-        (fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host))
-      ) === -1 /* LessThan */ ? fix : best
+      (best, fix) => (
+        // Takes true branch of conditional if `fix` is better than `best`
+        compareModuleSpecifiers(
+          fix,
+          best,
+          sourceFile,
+          program,
+          packageJsonImportFilter.allowsImportingSpecifier,
+          (fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host))
+        ) === -1 /* LessThan */ ? fix : best
+      )
     );
   }
   function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier, toPath3) {
@@ -145465,7 +145535,10 @@ ${lanes.join("\n")}
           return containingNodeKind === 257 /* VariableDeclaration */ || isVariableDeclarationListButNotTypeArgument(contextToken2) || containingNodeKind === 240 /* VariableStatement */ || containingNodeKind === 263 /* EnumDeclaration */ || // enum a { foo, |
           isFunctionLikeButNotConstructor(containingNodeKind) || containingNodeKind === 261 /* InterfaceDeclaration */ || // interface A<T, |
           containingNodeKind === 204 /* ArrayBindingPattern */ || // var [x, y|
-          containingNodeKind === 262 /* TypeAliasDeclaration */ || isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos;
+          containingNodeKind === 262 /* TypeAliasDeclaration */ || // type Map, K, |
+          // class A<T, |
+          // var C = class D<T, |
+          isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos;
         case 24 /* DotToken */:
           return containingNodeKind === 204 /* ArrayBindingPattern */;
         case 58 /* ColonToken */:
@@ -147482,8 +147555,10 @@ ${lanes.join("\n")}
     return map2;
   }
   function forEachPossibleImportOrExportStatement(sourceFileLike, action) {
-    return forEach(sourceFileLike.kind === 308 /* SourceFile */ ? sourceFileLike.statements : sourceFileLike.body.statements, (statement) => // TODO: GH#18217
-    action(statement) || isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action));
+    return forEach(sourceFileLike.kind === 308 /* SourceFile */ ? sourceFileLike.statements : sourceFileLike.body.statements, (statement) => (
+      // TODO: GH#18217
+      action(statement) || isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action)
+    ));
   }
   function forEachImport(sourceFile, action) {
     if (sourceFile.externalModuleIndicator || sourceFile.imports !== void 0) {
@@ -147752,7 +147827,9 @@ ${lanes.join("\n")}
       return propertyName ? getContextNode(propertyName.parent) : void 0;
     }
     if (node.parent.name === node || // node is name of declaration, use parent
-    isConstructorDeclaration(node.parent) || isExportAssignment(node.parent) || (isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent)) && node.parent.propertyName === node || node.kind === 88 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 1025 /* ExportDefault */)) {
+    isConstructorDeclaration(node.parent) || isExportAssignment(node.parent) || // Property name of the import export specifier or binding pattern, use parent
+    (isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent)) && node.parent.propertyName === node || // Is default export
+    node.kind === 88 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 1025 /* ExportDefault */)) {
       return getContextNode(node.parent);
     }
     return void 0;
@@ -147806,11 +147883,13 @@ ${lanes.join("\n")}
     const checker = program.getTypeChecker();
     const adjustedNode = Core.getAdjustedNode(node, options);
     const symbol = isDefinitionForReference(adjustedNode) ? checker.getSymbolAtLocation(adjustedNode) : void 0;
-    return !referencedSymbols || !referencedSymbols.length ? void 0 : mapDefined(referencedSymbols, ({ definition, references }) => // Only include referenced symbols that have a valid definition.
-    definition && {
-      definition: checker.runWithCancellationToken(cancellationToken, (checker2) => definitionToReferencedSymbolDefinitionInfo(definition, checker2, node)),
-      references: references.map((r) => toReferencedSymbolEntry(r, symbol))
-    });
+    return !referencedSymbols || !referencedSymbols.length ? void 0 : mapDefined(referencedSymbols, ({ definition, references }) => (
+      // Only include referenced symbols that have a valid definition.
+      definition && {
+        definition: checker.runWithCancellationToken(cancellationToken, (checker2) => definitionToReferencedSymbolDefinitionInfo(definition, checker2, node)),
+        references: references.map((r) => toReferencedSymbolEntry(r, symbol))
+      }
+    ));
   }
   function isDefinitionForReference(node) {
     return node.kind === 88 /* DefaultKeyword */ || !!getDeclarationFromName(node) || isLiteralComputedPropertyDeclarationName(node) || node.kind === 135 /* ConstructorKeyword */ && isConstructorDeclaration(node.parent);
@@ -148848,8 +148927,10 @@ ${lanes.join("\n")}
         function getLabelReferencesInNode(container, targetLabel) {
           const sourceFile = container.getSourceFile();
           const labelName = targetLabel.text;
-          const references = mapDefined(getPossibleSymbolReferenceNodes(sourceFile, labelName, container), (node) => // Only pick labels that are either the target label, or have a target that is the target label
-          node === targetLabel || isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel ? nodeEntry(node) : void 0);
+          const references = mapDefined(getPossibleSymbolReferenceNodes(sourceFile, labelName, container), (node) => (
+            // Only pick labels that are either the target label, or have a target that is the target label
+            node === targetLabel || isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel ? nodeEntry(node) : void 0
+          ));
           return [{ definition: { type: 1 /* Label */, node: targetLabel }, references }];
         }
         function isValidReferencePosition(node, searchSymbolName) {
@@ -157990,7 +158071,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           hasAddedSymbolInfo = true;
           hasMultipleSignatures = allSignatures.length > 1;
         }
-      } else if (isNameOfFunctionDeclaration(location) && !(symbolFlags & 98304 /* Accessor */) || location.kind === 135 /* ConstructorKeyword */ && location.parent.kind === 173 /* Constructor */) {
+      } else if (isNameOfFunctionDeclaration(location) && !(symbolFlags & 98304 /* Accessor */) || // name of function declaration
+      location.kind === 135 /* ConstructorKeyword */ && location.parent.kind === 173 /* Constructor */) {
         const functionDeclaration = location.parent;
         const locationIsSymbolDeclaration = symbol.declarations && find(symbol.declarations, (declaration) => declaration === (location.kind === 135 /* ConstructorKeyword */ ? functionDeclaration.parent : functionDeclaration));
         if (locationIsSymbolDeclaration) {
@@ -160328,18 +160410,12 @@ ${options.prefix}` : "\n" : options.prefix
       rule("NoSpaceBetweenCloseParenAndAngularBracket", 21 /* CloseParenToken */, 29 /* LessThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
       rule("NoSpaceAfterOpenAngularBracket", 29 /* LessThanToken */, anyToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
       rule("NoSpaceBeforeCloseAngularBracket", anyToken, 31 /* GreaterThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
-      rule(
-        "NoSpaceAfterCloseAngularBracket",
-        31 /* GreaterThanToken */,
-        [20 /* OpenParenToken */, 22 /* OpenBracketToken */, 31 /* GreaterThanToken */, 27 /* CommaToken */],
-        [
-          isNonJsxSameLineTokenContext,
-          isTypeArgumentOrParameterOrAssertionContext,
-          isNotFunctionDeclContext
-          /*To prevent an interference with the SpaceBeforeOpenParenInFuncDecl rule*/
-        ],
-        16 /* DeleteSpace */
-      ),
+      rule("NoSpaceAfterCloseAngularBracket", 31 /* GreaterThanToken */, [20 /* OpenParenToken */, 22 /* OpenBracketToken */, 31 /* GreaterThanToken */, 27 /* CommaToken */], [
+        isNonJsxSameLineTokenContext,
+        isTypeArgumentOrParameterOrAssertionContext,
+        isNotFunctionDeclContext,
+        isNonTypeAssertionContext
+      ], 16 /* DeleteSpace */),
       // decorators
       rule("SpaceBeforeAt", [21 /* CloseParenToken */, 79 /* Identifier */], 59 /* AtToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
       rule("NoSpaceAfterAt", 59 /* AtToken */, anyToken, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
@@ -160772,6 +160848,9 @@ ${options.prefix}` : "\n" : options.prefix
   function isTypeAssertionContext(context) {
     return context.contextNode.kind === 213 /* TypeAssertionExpression */;
   }
+  function isNonTypeAssertionContext(context) {
+    return !isTypeAssertionContext(context);
+  }
   function isVoidOpContext(context) {
     return context.currentTokenSpan.kind === 114 /* VoidKeyword */ && context.currentTokenParent.kind === 219 /* VoidExpression */;
   }
@@ -165751,6 +165830,7 @@ ${options.prefix}` : "\n" : options.prefix
     isNonContextualKeyword: () => isNonContextualKeyword,
     isNonGlobalAmbientModule: () => isNonGlobalAmbientModule,
     isNonGlobalDeclaration: () => isNonGlobalDeclaration,
+    isNonNullAccess: () => isNonNullAccess,
     isNonNullChain: () => isNonNullChain,
     isNonNullExpression: () => isNonNullExpression,
     isNonStaticMethodOrAccessorWithPrivateName: () => isNonStaticMethodOrAccessorWithPrivateName,