typescript 5.0.0-dev.20230201 → 5.0.0-dev.20230203

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230201`;
+var version = `${versionMajorMinor}.0-dev.20230203`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6051,7 +6051,6 @@ var Diagnostics = {
   Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, 1 /* Error */, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."),
   Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, 1 /* Error */, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"),
   Class_constructor_may_not_be_an_accessor: diag(1341, 1 /* Error */, "Class_constructor_may_not_be_an_accessor_1341", "Class constructor may not be an accessor."),
-  Type_arguments_cannot_be_used_here: diag(1342, 1 /* Error */, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."),
   The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext: diag(1343, 1 /* Error */, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', or 'nodenext'."),
   A_label_is_not_allowed_here: diag(1344, 1 /* Error */, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."),
   An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, 1 /* Error */, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."),
@@ -6697,7 +6696,7 @@ var Diagnostics = {
   Private_accessor_was_defined_without_a_getter: diag(2806, 1 /* Error */, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."),
   This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: diag(2807, 1 /* Error */, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."),
   A_get_accessor_must_be_at_least_as_accessible_as_the_setter: diag(2808, 1 /* Error */, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"),
-  Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses: diag(2809, 1 /* Error */, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the the whole assignment in parentheses."),
+  Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses: diag(2809, 1 /* Error */, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the whole assignment in parentheses."),
   Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments: diag(2810, 1 /* Error */, "Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_2810", "Expected 1 argument, but got 0. 'new Promise()' needs a JSDoc hint to produce a 'resolve' that can be called without arguments."),
   Initializer_for_property_0: diag(2811, 1 /* Error */, "Initializer_for_property_0_2811", "Initializer for property '{0}'"),
   Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: diag(2812, 1 /* Error */, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."),
@@ -10712,6 +10711,9 @@ function isFunctionLikeOrClassStaticBlockDeclaration(node) {
 function isFunctionLikeDeclaration(node) {
   return node && isFunctionLikeDeclarationKind(node.kind);
 }
+function isBooleanLiteral(node) {
+  return node.kind === 110 /* TrueKeyword */ || node.kind === 95 /* FalseKeyword */;
+}
 function isFunctionLikeDeclarationKind(kind) {
   switch (kind) {
     case 259 /* FunctionDeclaration */:
@@ -29623,7 +29625,7 @@ var Parser;
       parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
       const result = withJSDoc(finishNode(factory2.createBlock(statements, multiLine), pos), hasJSDoc);
       if (token() === 63 /* EqualsToken */) {
-        parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses);
+        parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses);
         nextToken();
       }
       return result;
@@ -35953,6 +35955,22 @@ function resolvedTypeScriptOnly(resolved) {
   Debug.assert(extensionIsTS(resolved.extension));
   return { fileName: resolved.path, packageId: resolved.packageId };
 }
+function createResolvedModuleWithFailedLookupLocationsHandlingSymlink(moduleName, resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state, legacyResult) {
+  if (!state.resultFromCache && !state.compilerOptions.preserveSymlinks && resolved && isExternalLibraryImport && !resolved.originalPath && !isExternalModuleNameRelative(moduleName)) {
+    const { resolvedFileName, originalPath } = getOriginalAndResolvedFileName(resolved.path, state.host, state.traceEnabled);
+    if (originalPath)
+      resolved = { ...resolved, path: resolvedFileName, originalPath };
+  }
+  return createResolvedModuleWithFailedLookupLocations(
+    resolved,
+    isExternalLibraryImport,
+    failedLookupLocations,
+    affectingLocations,
+    diagnostics,
+    state.resultFromCache,
+    legacyResult
+  );
+}
 function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache, legacyResult) {
   if (resultFromCache) {
     resultFromCache.failedLookupLocations = updateResolutionField(resultFromCache.failedLookupLocations, failedLookupLocations);
@@ -36113,6 +36131,15 @@ function arePathsEqual(path1, path2, host) {
   const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
   return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 0 /* EqualTo */;
 }
+function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {
+  const resolvedFileName = realPath(fileName, host, traceEnabled);
+  const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);
+  return {
+    // If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames
+    resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,
+    originalPath: pathsAreEqual ? void 0 : fileName
+  };
+}
 function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
   Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");
   const traceEnabled = isTraceEnabled(options, host);
@@ -36184,13 +36211,13 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   let resolvedTypeReferenceDirective;
   if (resolved) {
     const { fileName, packageId } = resolved;
-    const resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);
-    const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);
+    let resolvedFileName = fileName, originalPath;
+    if (!options.preserveSymlinks)
+      ({ resolvedFileName, originalPath } = getOriginalAndResolvedFileName(fileName, host, traceEnabled));
     resolvedTypeReferenceDirective = {
       primary,
-      // If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames
-      resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,
-      originalPath: pathsAreEqual ? void 0 : fileName,
+      resolvedFileName,
+      originalPath,
       packageId,
       isExternalLibraryImport: pathContainsNodeModules(fileName)
     };
@@ -37048,13 +37075,14 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
       legacyResult = diagnosticResult.value.resolved.path;
     }
   }
-  return createResolvedModuleWithFailedLookupLocations(
+  return createResolvedModuleWithFailedLookupLocationsHandlingSymlink(
+    moduleName,
     (_c = result == null ? void 0 : result.value) == null ? void 0 : _c.resolved,
     (_d = result == null ? void 0 : result.value) == null ? void 0 : _d.isExternalLibraryImport,
     failedLookupLocations,
     affectingLocations,
     diagnostics,
-    state.resultFromCache,
+    state,
     legacyResult
   );
   function tryResolve(extensions2, state2) {
@@ -37084,16 +37112,7 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
         }
         resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
       }
-      if (!resolved2)
-        return void 0;
-      let resolvedValue = resolved2.value;
-      if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) {
-        const path = realPath(resolvedValue.path, host, traceEnabled);
-        const pathsAreEqual = arePathsEqual(path, resolvedValue.path, host);
-        const originalPath = pathsAreEqual ? void 0 : resolvedValue.path;
-        resolvedValue = { ...resolvedValue, path: pathsAreEqual ? resolvedValue.path : path, originalPath };
-      }
-      return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
+      return resolved2 && { value: resolved2.value && { resolved: resolved2.value, isExternalLibraryImport: true } };
     } else {
       const { path: candidate, parts } = normalizePathForCJSResolution(containingDirectory, moduleName);
       const resolved2 = nodeLoadModuleByRelativeName(
@@ -38148,13 +38167,14 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
     candidateIsFromPackageJsonField: false
   };
   const resolved = tryResolve(1 /* TypeScript */ | 4 /* Declaration */) || tryResolve(2 /* JavaScript */ | (compilerOptions.resolveJsonModule ? 8 /* Json */ : 0));
-  return createResolvedModuleWithFailedLookupLocations(
+  return createResolvedModuleWithFailedLookupLocationsHandlingSymlink(
+    moduleName,
     resolved && resolved.value,
     (resolved == null ? void 0 : resolved.value) && pathContainsNodeModules(resolved.value.path),
     failedLookupLocations,
     affectingLocations,
     diagnostics,
-    state.resultFromCache
+    state
   );
   function tryResolve(extensions) {
     const resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
@@ -41833,8 +41853,10 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
       const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
       const importMode = overrideMode || importingSourceFile.impliedNodeFormat;
       if (getResolvePackageJsonExports(options)) {
+        const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
+        const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2);
         const conditions = getConditions(options, importMode === 99 /* ESNext */);
-        const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions) : void 0;
+        const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0;
         if (fromExports) {
           const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
           return { ...withJsExtension, verbatimFromExports: true };
@@ -44300,7 +44322,12 @@ function createTypeChecker(host) {
   }
   function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) {
     const exportValue = moduleSymbol.exports.get("export=" /* ExportEquals */);
-    const exportSymbol = exportValue ? getPropertyOfType(getTypeOfSymbol(exportValue), name) : moduleSymbol.exports.get(name);
+    const exportSymbol = exportValue ? getPropertyOfType(
+      getTypeOfSymbol(exportValue),
+      name,
+      /*skipObjectFunctionPropertyAugment*/
+      true
+    ) : moduleSymbol.exports.get(name);
     const resolved = resolveSymbol(exportSymbol, dontResolveAlias);
     markSymbolOfAliasDeclarationIfTypeOnly(
       sourceNode,
@@ -53715,7 +53742,7 @@ function createTypeChecker(host) {
             for (const tag of node.tags) {
               if (isJSDocOverloadTag(tag)) {
                 const jsDocSignature = tag.typeExpression;
-                if (jsDocSignature.type === void 0) {
+                if (jsDocSignature.type === void 0 && !isConstructorDeclaration(decl)) {
                   reportImplicitAny(jsDocSignature, anyType);
                 }
                 result.push(getSignatureFromDeclaration(jsDocSignature));
@@ -53827,6 +53854,12 @@ function createTypeChecker(host) {
     if (declaration.kind === 173 /* Constructor */) {
       return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol));
     }
+    if (isJSDocSignature(declaration)) {
+      const root = getJSDocRoot(declaration);
+      if (root && isConstructorDeclaration(root.parent)) {
+        return getDeclaredTypeOfClassOrInterface(getMergedSymbol(root.parent.parent.symbol));
+      }
+    }
     if (isJSDocConstructSignature(declaration)) {
       return getTypeFromTypeNode(declaration.parameters[0].type);
     }
@@ -55417,7 +55450,7 @@ function createTypeChecker(host) {
   function typePredicateKindsMatch(a, b) {
     return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
   }
-  function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) {
+  function getUnionTypeFromSortedList(types, precomputedObjectFlags, aliasSymbol, aliasTypeArguments, origin) {
     if (types.length === 0) {
       return neverType;
     }
@@ -55429,7 +55462,7 @@ function createTypeChecker(host) {
     let type = unionTypes.get(id);
     if (!type) {
       type = createType(1048576 /* Union */);
-      type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(
+      type.objectFlags = precomputedObjectFlags | getPropagatingFlagsOfTypes(
         types,
         /*excludeKinds*/
         98304 /* Nullable */
@@ -56606,11 +56639,6 @@ function createTypeChecker(host) {
     var _a2;
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
-      if (node.isTypeOf && node.typeArguments) {
-        error(node, Diagnostics.Type_arguments_cannot_be_used_here);
-        links.resolvedSymbol = unknownSymbol;
-        return links.resolvedType = errorType;
-      }
       if (!isLiteralImportTypeNode(node)) {
         error(node.argument, Diagnostics.String_literal_expected);
         links.resolvedSymbol = unknownSymbol;
@@ -56671,7 +56699,7 @@ function createTypeChecker(host) {
     const resolvedSymbol = resolveSymbol(symbol);
     links.resolvedSymbol = resolvedSymbol;
     if (meaning === 111551 /* Value */) {
-      return getTypeOfSymbol(symbol);
+      return getInstantiationExpressionType(getTypeOfSymbol(symbol), node);
     } else {
       const type = tryGetDeclaredTypeOfSymbol(resolvedSymbol);
       const typeParameters = type && getTypeParametersForTypeAndSymbol(type, resolvedSymbol);
@@ -58552,7 +58580,6 @@ function createTypeChecker(host) {
     let overrideNextErrorInfo = 0;
     let lastSkippedInfo;
     let incompatibleStack;
-    let inPropertyCheck = false;
     Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
     const result = isRelatedTo(
       source,
@@ -58749,7 +58776,8 @@ function createTypeChecker(host) {
         Debug.assert(!isTypeAssignableTo(generalizedSource, target2), "generalized source shouldn't be assignable");
         generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource);
       }
-      if (target2.flags & 262144 /* TypeParameter */ && target2 !== markerSuperTypeForCheck && target2 !== markerSubTypeForCheck) {
+      const targetFlags = target2.flags & 8388608 /* IndexedAccess */ && !(source2.flags & 8388608 /* IndexedAccess */) ? target2.objectType.flags : target2.flags;
+      if (targetFlags & 262144 /* TypeParameter */ && target2 !== markerSuperTypeForCheck && target2 !== markerSubTypeForCheck) {
         const constraint = getBaseConstraintOfType(target2);
         let needsOriginalSource;
         if (constraint && (isTypeAssignableTo(generalizedSource, constraint) || (needsOriginalSource = isTypeAssignableTo(source2, constraint)))) {
@@ -59510,14 +59538,15 @@ function createTypeChecker(host) {
             );
           }
         }
-        if (result2 && !inPropertyCheck && (target2.flags & 2097152 /* Intersection */ && !isGenericObjectType(target2) && source2.flags & (524288 /* Object */ | 2097152 /* Intersection */) || isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */)))) {
-          inPropertyCheck = true;
+        if (result2 && !(intersectionState & 2 /* Target */) && target2.flags & 2097152 /* Intersection */ && !isGenericObjectType(target2) && source2.flags & (524288 /* Object */ | 2097152 /* Intersection */)) {
           result2 &= propertiesRelatedTo(
             source2,
             target2,
             reportErrors2,
             /*excludedProperties*/
             void 0,
+            /*optionalsOnly*/
+            false,
             0 /* None */
           );
           if (result2 && isObjectLiteralType(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */) {
@@ -59530,7 +59559,17 @@ function createTypeChecker(host) {
               0 /* None */
             );
           }
-          inPropertyCheck = false;
+        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
+          result2 &= propertiesRelatedTo(
+            source2,
+            target2,
+            reportErrors2,
+            /*excludedProperties*/
+            void 0,
+            /*optionalsOnly*/
+            true,
+            intersectionState
+          );
         }
       }
       if (result2) {
@@ -60020,12 +60059,14 @@ function createTypeChecker(host) {
             reportStructuralErrors,
             /*excludedProperties*/
             void 0,
+            /*optionalsOnly*/
+            false,
             intersectionState
           );
           if (result2) {
-            result2 &= signaturesRelatedTo(source2, target2, 0 /* Call */, reportStructuralErrors);
+            result2 &= signaturesRelatedTo(source2, target2, 0 /* Call */, reportStructuralErrors, intersectionState);
             if (result2) {
-              result2 &= signaturesRelatedTo(source2, target2, 1 /* Construct */, reportStructuralErrors);
+              result2 &= signaturesRelatedTo(source2, target2, 1 /* Construct */, reportStructuralErrors, intersectionState);
               if (result2) {
                 result2 &= indexSignaturesRelatedTo(source2, target2, sourceIsPrimitive, reportStructuralErrors, intersectionState);
               }
@@ -60154,6 +60195,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           excludedProperties,
+          /*optionalsOnly*/
+          false,
           0 /* None */
         );
         if (result2) {
@@ -60162,7 +60205,8 @@ function createTypeChecker(host) {
             type,
             0 /* Call */,
             /*reportStructuralErrors*/
-            false
+            false,
+            0 /* None */
           );
           if (result2) {
             result2 &= signaturesRelatedTo(
@@ -60170,7 +60214,8 @@ function createTypeChecker(host) {
               type,
               1 /* Construct */,
               /*reportStructuralErrors*/
-              false
+              false,
+              0 /* None */
             );
             if (result2 && !(isTupleType(source2) && isTupleType(type))) {
               result2 &= indexSignaturesRelatedTo(
@@ -60348,7 +60393,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    function propertiesRelatedTo(source2, target2, reportErrors2, excludedProperties, intersectionState) {
+    function propertiesRelatedTo(source2, target2, reportErrors2, excludedProperties, optionalsOnly, intersectionState) {
       if (relation === identityRelation) {
         return propertiesIdenticalTo(source2, target2, excludedProperties);
       }
@@ -60484,7 +60529,7 @@ function createTypeChecker(host) {
       const numericNamesOnly = isTupleType(source2) && isTupleType(target2);
       for (const targetProp of excludeProperties(properties, excludedProperties)) {
         const name = targetProp.escapedName;
-        if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
+        if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length") && (!optionalsOnly || targetProp.flags & 16777216 /* Optional */)) {
           const sourceProp = getPropertyOfType(source2, name);
           if (sourceProp && sourceProp !== targetProp) {
             const related = propertyRelatedTo(source2, target2, sourceProp, targetProp, getNonMissingTypeOfSymbol, reportErrors2, intersectionState, relation === comparableRelation);
@@ -60520,7 +60565,7 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function signaturesRelatedTo(source2, target2, kind, reportErrors2) {
+    function signaturesRelatedTo(source2, target2, kind, reportErrors2, intersectionState) {
       var _a3, _b;
       if (relation === identityRelation) {
         return signaturesIdenticalTo(source2, target2, kind);
@@ -60557,6 +60602,7 @@ function createTypeChecker(host) {
             /*erase*/
             true,
             reportErrors2,
+            intersectionState,
             incompatibleReporter(sourceSignatures[i], targetSignatures[i])
           );
           if (!related) {
@@ -60568,7 +60614,7 @@ function createTypeChecker(host) {
         const eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
         const sourceSignature = first(sourceSignatures);
         const targetSignature = first(targetSignatures);
-        result2 = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors2, incompatibleReporter(sourceSignature, targetSignature));
+        result2 = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors2, intersectionState, incompatibleReporter(sourceSignature, targetSignature));
         if (!result2 && reportErrors2 && kind === 1 /* Construct */ && sourceObjectFlags & targetObjectFlags && (((_a3 = targetSignature.declaration) == null ? void 0 : _a3.kind) === 173 /* Constructor */ || ((_b = sourceSignature.declaration) == null ? void 0 : _b.kind) === 173 /* Constructor */)) {
           const constructSignatureToString = (signature) => signatureToString(
             signature,
@@ -60593,6 +60639,7 @@ function createTypeChecker(host) {
                 /*erase*/
                 true,
                 shouldElaborateErrors,
+                intersectionState,
                 incompatibleReporter(s, t)
               );
               if (related) {
@@ -60645,7 +60692,7 @@ function createTypeChecker(host) {
       }
       return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
     }
-    function signatureRelatedTo(source2, target2, erase, reportErrors2, incompatibleReporter) {
+    function signatureRelatedTo(source2, target2, erase, reportErrors2, intersectionState, incompatibleReporter) {
       return compareSignaturesRelated(
         erase ? getErasedSignature(source2) : source2,
         erase ? getErasedSignature(target2) : target2,
@@ -60653,9 +60700,20 @@ function createTypeChecker(host) {
         reportErrors2,
         reportError,
         incompatibleReporter,
-        isRelatedToWorker,
+        isRelatedToWorker2,
         reportUnreliableMapper
       );
+      function isRelatedToWorker2(source3, target3, reportErrors3) {
+        return isRelatedTo(
+          source3,
+          target3,
+          3 /* Both */,
+          reportErrors3,
+          /*headMessage*/
+          void 0,
+          intersectionState
+        );
+      }
     }
     function signaturesIdenticalTo(source2, target2, kind) {
       const sourceSignatures = getSignaturesOfType(source2, kind);
@@ -60714,7 +60772,7 @@ function createTypeChecker(host) {
       }
       for (const info of getIndexInfosOfType(source2)) {
         if (isApplicableIndexType(info.keyType, keyType)) {
-          const related = indexInfoRelatedTo(info, targetInfo, reportErrors2);
+          const related = indexInfoRelatedTo(info, targetInfo, reportErrors2, intersectionState);
           if (!related) {
             return 0 /* False */;
           }
@@ -60723,8 +60781,16 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2) {
-      const related = isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */, reportErrors2);
+    function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2, intersectionState) {
+      const related = isRelatedTo(
+        sourceInfo.type,
+        targetInfo.type,
+        3 /* Both */,
+        reportErrors2,
+        /*headMessage*/
+        void 0,
+        intersectionState
+      );
       if (!related && reportErrors2) {
         if (sourceInfo.keyType === targetInfo.keyType) {
           reportError(Diagnostics._0_index_signatures_are_incompatible, typeToString(sourceInfo.keyType));
@@ -60753,7 +60819,7 @@ function createTypeChecker(host) {
     function typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState) {
       const sourceInfo = getApplicableIndexInfo(source2, targetInfo.keyType);
       if (sourceInfo) {
-        return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2);
+        return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2, intersectionState);
       }
       if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
         return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
@@ -61044,12 +61110,15 @@ function createTypeChecker(host) {
   }
   function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
     if (depth >= maxDepth) {
+      if (type.flags & 2097152 /* Intersection */) {
+        return some(type.types, (t) => isDeeplyNestedType(t, stack, depth, maxDepth));
+      }
       const identity2 = getRecursionIdentity(type);
       let count = 0;
       let lastTypeId = 0;
       for (let i = 0; i < depth; i++) {
         const t = stack[i];
-        if (getRecursionIdentity(t) === identity2) {
+        if (t.flags & 2097152 /* Intersection */ ? some(t.types, (u) => getRecursionIdentity(u) === identity2) : getRecursionIdentity(t) === identity2) {
           if (t.id >= lastTypeId) {
             count++;
             if (count >= maxDepth) {
@@ -63417,7 +63486,7 @@ function createTypeChecker(host) {
       }
       return getUnionTypeFromSortedList(
         filtered,
-        type.objectFlags,
+        type.objectFlags & (32768 /* PrimitiveUnion */ | 16777216 /* ContainsIntersections */),
         /*aliasSymbol*/
         void 0,
         /*aliasTypeArguments*/
@@ -70068,7 +70137,7 @@ function createTypeChecker(host) {
     }
   }
   function checkCallExpression(node, checkMode) {
-    var _a2;
+    var _a2, _b, _c;
     checkGrammarTypeArguments(node, node.typeArguments);
     const signature = getResolvedSignature(
       node,
@@ -70085,7 +70154,7 @@ function createTypeChecker(host) {
     }
     if (node.kind === 211 /* NewExpression */) {
       const declaration = signature.declaration;
-      if (declaration && declaration.kind !== 173 /* Constructor */ && declaration.kind !== 177 /* ConstructSignature */ && declaration.kind !== 182 /* ConstructorType */ && !isJSDocConstructSignature(declaration) && !isJSConstructor(declaration)) {
+      if (declaration && declaration.kind !== 173 /* Constructor */ && declaration.kind !== 177 /* ConstructSignature */ && declaration.kind !== 182 /* ConstructorType */ && !(isJSDocSignature(declaration) && ((_b = (_a2 = getJSDocRoot(declaration)) == null ? void 0 : _a2.parent) == null ? void 0 : _b.kind) === 173 /* Constructor */) && !isJSDocConstructSignature(declaration) && !isJSConstructor(declaration)) {
         if (noImplicitAny) {
           error(node, Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
         }
@@ -70113,7 +70182,7 @@ function createTypeChecker(host) {
         /*allowDeclaration*/
         false
       );
-      if ((_a2 = jsSymbol == null ? void 0 : jsSymbol.exports) == null ? void 0 : _a2.size) {
+      if ((_c = jsSymbol == null ? void 0 : jsSymbol.exports) == null ? void 0 : _c.size) {
         const jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, emptyArray, emptyArray, emptyArray);
         jsAssignmentType.objectFlags |= 4096 /* JSLiteral */;
         return getIntersectionType([returnType, jsAssignmentType]);
@@ -70399,6 +70468,9 @@ function createTypeChecker(host) {
     checkGrammarExpressionWithTypeArguments(node);
     forEach(node.typeArguments, checkSourceElement);
     const exprType = node.kind === 230 /* ExpressionWithTypeArguments */ ? checkExpression(node.expression) : isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : checkExpression(node.exprName);
+    return getInstantiationExpressionType(exprType, node);
+  }
+  function getInstantiationExpressionType(exprType, node) {
     const typeArguments = node.typeArguments;
     if (exprType === silentNeverType || isErrorType(exprType) || !some(typeArguments)) {
       return exprType;
@@ -73037,7 +73109,7 @@ function createTypeChecker(host) {
       return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
     } else if (isAssertionExpression(expr) && !isConstTypeReference(expr.type)) {
       return getTypeFromTypeNode(expr.type);
-    } else if (node.kind === 8 /* NumericLiteral */ || node.kind === 10 /* StringLiteral */ || node.kind === 110 /* TrueKeyword */ || node.kind === 95 /* FalseKeyword */) {
+    } else if (isLiteralExpression(node) || isBooleanLiteral(node)) {
       return checkExpression(node);
     }
     return void 0;
@@ -103891,7 +103963,7 @@ function transformDeclarations(context) {
       if (elem.kind === 229 /* OmittedExpression */) {
         return elem;
       }
-      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced) {
+      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced && !isIdentifierANonContextualKeyword(elem.propertyName)) {
         return factory2.updateBindingElement(
           elem,
           elem.dotDotDotToken,