typescript 5.0.0-dev.20230220 → 5.0.0-dev.20230222

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.20230220`;
+var version = `${versionMajorMinor}.0-dev.20230222`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6896,7 +6896,7 @@ var Diagnostics = {
   Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler: diag(5098, 1 /* Error */, "Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler_5098", "Option '{0}' can only be used when 'moduleResolution' is set to 'node16', 'nodenext', or 'bundler'."),
   Import_assignment_is_not_allowed_when_moduleResolution_is_set_to_bundler_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: diag(5099, 1 /* Error */, "Import_assignment_is_not_allowed_when_moduleResolution_is_set_to_bundler_Consider_using_import_Aster_5099", `Import assignment is not allowed when 'moduleResolution' is set to 'bundler'. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead.`),
   Export_assignment_cannot_be_used_when_moduleResolution_is_set_to_bundler_Consider_using_export_default_or_another_module_format_instead: diag(5100, 1 /* Error */, "Export_assignment_cannot_be_used_when_moduleResolution_is_set_to_bundler_Consider_using_export_defau_5100", "Export assignment cannot be used when 'moduleResolution' is set to 'bundler'. Consider using 'export default' or another module format instead."),
-  Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_ignoreDeprecations_Colon_2_to_silence_this_error: diag(5101, 1 /* Error */, "Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_ignoreDeprecations_Colon_2_to_5101", `Flag '{0}' is deprecated and will stop functioning in TypeScript {1}. Specify 'ignoreDeprecations: "{2}"' to silence this error.`),
+  Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error: diag(5101, 1 /* Error */, "Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecat_5101", `Flag '{0}' is deprecated and will stop functioning in TypeScript {1}. Specify compilerOption '"ignoreDeprecations": "{2}"' to silence this error.`),
   Flag_0_is_deprecated_Please_remove_it_from_your_configuration: diag(5102, 1 /* Error */, "Flag_0_is_deprecated_Please_remove_it_from_your_configuration_5102", "Flag '{0}' is deprecated. Please remove it from your configuration."),
   Invalid_value_for_ignoreDeprecations: diag(5103, 1 /* Error */, "Invalid_value_for_ignoreDeprecations_5103", "Invalid value for '--ignoreDeprecations'."),
   Option_0_is_redundant_and_cannot_be_specified_with_option_1: diag(5104, 1 /* Error */, "Option_0_is_redundant_and_cannot_be_specified_with_option_1_5104", "Option '{0}' is redundant and cannot be specified with option '{1}'."),
@@ -15744,9 +15744,6 @@ function getClassLikeDeclarationOfSymbol(symbol) {
 function getObjectFlags(type) {
   return type.flags & 3899393 /* ObjectFlagsType */ ? type.objectFlags : 0;
 }
-function typeHasCallOrConstructSignatures(type, checker) {
-  return checker.getSignaturesOfType(type, 0 /* Call */).length !== 0 || checker.getSignaturesOfType(type, 1 /* Construct */).length !== 0;
-}
 function isUMDExportSymbol(symbol) {
   return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && isNamespaceExportDeclaration(symbol.declarations[0]);
 }
@@ -38809,35 +38806,36 @@ function bindSourceFile(file, options) {
   measure("Bind", "beforeBind", "afterBind");
 }
 function createBinder() {
-  let file;
-  let options;
-  let languageVersion;
-  let parent;
-  let container;
-  let thisParentContainer;
-  let blockScopeContainer;
-  let lastContainer;
-  let delayedTypeAliases;
-  let seenThisKeyword;
-  let currentFlow;
-  let currentBreakTarget;
-  let currentContinueTarget;
-  let currentReturnTarget;
-  let currentTrueTarget;
-  let currentFalseTarget;
-  let currentExceptionTarget;
-  let preSwitchCaseFlow;
-  let activeLabelList;
-  let hasExplicitReturn;
-  let emitFlags;
-  let inStrictMode;
-  let inAssignmentPattern = false;
-  let symbolCount = 0;
-  let Symbol12;
-  let classifiableNames;
-  const unreachableFlow = { flags: 1 /* Unreachable */ };
-  const reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
-  const bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
+  var file;
+  var options;
+  var languageVersion;
+  var parent;
+  var container;
+  var thisParentContainer;
+  var blockScopeContainer;
+  var lastContainer;
+  var delayedTypeAliases;
+  var seenThisKeyword;
+  var currentFlow;
+  var currentBreakTarget;
+  var currentContinueTarget;
+  var currentReturnTarget;
+  var currentTrueTarget;
+  var currentFalseTarget;
+  var currentExceptionTarget;
+  var preSwitchCaseFlow;
+  var activeLabelList;
+  var hasExplicitReturn;
+  var emitFlags;
+  var inStrictMode;
+  var inAssignmentPattern = false;
+  var symbolCount = 0;
+  var Symbol12;
+  var classifiableNames;
+  var unreachableFlow = { flags: 1 /* Unreachable */ };
+  var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
+  var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
+  return bindSourceFile2;
   function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
     return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
   }
@@ -38888,7 +38886,6 @@ function createBinder() {
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
   }
-  return bindSourceFile2;
   function bindInStrictMode(file2, opts) {
     if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
       return true;
@@ -42549,8 +42546,8 @@ function isInstantiatedModule(node, preserveConstEnums) {
   return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
 }
 function createTypeChecker(host) {
-  const getPackagesMap = memoize(() => {
-    const map2 = /* @__PURE__ */ new Map();
+  var getPackagesMap = memoize(() => {
+    var map2 = /* @__PURE__ */ new Map();
     host.getSourceFiles().forEach((sf) => {
       if (!sf.resolvedModules)
         return;
@@ -42561,58 +42558,58 @@ function createTypeChecker(host) {
     });
     return map2;
   });
-  let deferredDiagnosticsCallbacks = [];
-  let addLazyDiagnostic = (arg) => {
+  var deferredDiagnosticsCallbacks = [];
+  var addLazyDiagnostic = (arg) => {
     deferredDiagnosticsCallbacks.push(arg);
   };
-  let cancellationToken;
-  const requestedExternalEmitHelperNames = /* @__PURE__ */ new Set();
-  let requestedExternalEmitHelpers;
-  let externalHelpersModule;
-  const Symbol12 = objectAllocator.getSymbolConstructor();
-  const Type7 = objectAllocator.getTypeConstructor();
-  const Signature5 = objectAllocator.getSignatureConstructor();
-  let typeCount = 0;
-  let symbolCount = 0;
-  let totalInstantiationCount = 0;
-  let instantiationCount = 0;
-  let instantiationDepth = 0;
-  let inlineLevel = 0;
-  let currentNode;
-  let varianceTypeParameter;
-  let isInferencePartiallyBlocked = false;
-  const emptySymbols = createSymbolTable();
-  const arrayVariances = [1 /* Covariant */];
-  const compilerOptions = host.getCompilerOptions();
-  const languageVersion = getEmitScriptTarget(compilerOptions);
-  const moduleKind = getEmitModuleKind(compilerOptions);
-  const legacyDecorators = !!compilerOptions.experimentalDecorators;
-  const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
-  const allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
-  const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
-  const strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
-  const strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
-  const strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
-  const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
-  const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
-  const useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
-  const keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
-  const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
-  const exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
-  const checkBinaryExpression = createCheckBinaryExpression();
-  const emitResolver = createResolver();
-  const nodeBuilder = createNodeBuilder();
-  const globals = createSymbolTable();
-  const undefinedSymbol = createSymbol(4 /* Property */, "undefined");
+  var cancellationToken;
+  var requestedExternalEmitHelperNames = /* @__PURE__ */ new Set();
+  var requestedExternalEmitHelpers;
+  var externalHelpersModule;
+  var Symbol12 = objectAllocator.getSymbolConstructor();
+  var Type7 = objectAllocator.getTypeConstructor();
+  var Signature5 = objectAllocator.getSignatureConstructor();
+  var typeCount = 0;
+  var symbolCount = 0;
+  var totalInstantiationCount = 0;
+  var instantiationCount = 0;
+  var instantiationDepth = 0;
+  var inlineLevel = 0;
+  var currentNode;
+  var varianceTypeParameter;
+  var isInferencePartiallyBlocked = false;
+  var emptySymbols = createSymbolTable();
+  var arrayVariances = [1 /* Covariant */];
+  var compilerOptions = host.getCompilerOptions();
+  var languageVersion = getEmitScriptTarget(compilerOptions);
+  var moduleKind = getEmitModuleKind(compilerOptions);
+  var legacyDecorators = !!compilerOptions.experimentalDecorators;
+  var useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
+  var allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
+  var strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
+  var strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
+  var strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
+  var strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+  var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
+  var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
+  var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+  var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
+  var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
+  var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
+  var checkBinaryExpression = createCheckBinaryExpression();
+  var emitResolver = createResolver();
+  var nodeBuilder = createNodeBuilder();
+  var globals = createSymbolTable();
+  var undefinedSymbol = createSymbol(4 /* Property */, "undefined");
   undefinedSymbol.declarations = [];
-  const globalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */);
+  var globalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */);
   globalThisSymbol.exports = globals;
   globalThisSymbol.declarations = [];
   globals.set(globalThisSymbol.escapedName, globalThisSymbol);
-  const argumentsSymbol = createSymbol(4 /* Property */, "arguments");
-  const requireSymbol = createSymbol(4 /* Property */, "require");
-  const isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
-  let apparentArgumentCount;
+  var argumentsSymbol = createSymbol(4 /* Property */, "arguments");
+  var requireSymbol = createSymbol(4 /* Property */, "require");
+  var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
+  var apparentArgumentCount;
   const checker = {
     getNodeCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.nodeCount, 0),
     getIdentifierCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.identifierCount, 0),
@@ -42989,7 +42986,8 @@ function createTypeChecker(host) {
     isPropertyAccessible,
     getTypeOnlyAliasDeclaration,
     getMemberOverrideModifierStatus,
-    isTypeParameterPossiblyReferenced
+    isTypeParameterPossiblyReferenced,
+    typeHasCallOrConstructSignatures
   };
   function runWithoutResolvedSignatureCaching(node, fn) {
     const containingCall = findAncestor(node, isCallLikeExpression);
@@ -43031,50 +43029,50 @@ function createTypeChecker(host) {
     apparentArgumentCount = void 0;
     return res;
   }
-  const tupleTypes = /* @__PURE__ */ new Map();
-  const unionTypes = /* @__PURE__ */ new Map();
-  const intersectionTypes = /* @__PURE__ */ new Map();
-  const stringLiteralTypes = /* @__PURE__ */ new Map();
-  const numberLiteralTypes = /* @__PURE__ */ new Map();
-  const bigIntLiteralTypes = /* @__PURE__ */ new Map();
-  const enumLiteralTypes = /* @__PURE__ */ new Map();
-  const indexedAccessTypes = /* @__PURE__ */ new Map();
-  const templateLiteralTypes = /* @__PURE__ */ new Map();
-  const stringMappingTypes = /* @__PURE__ */ new Map();
-  const substitutionTypes = /* @__PURE__ */ new Map();
-  const subtypeReductionCache = /* @__PURE__ */ new Map();
-  const decoratorContextOverrideTypeCache = /* @__PURE__ */ new Map();
-  const cachedTypes = /* @__PURE__ */ new Map();
-  const evolvingArrayTypes = [];
-  const undefinedProperties = /* @__PURE__ */ new Map();
-  const markerTypes = /* @__PURE__ */ new Set();
-  const unknownSymbol = createSymbol(4 /* Property */, "unknown");
-  const resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
-  const unresolvedSymbols = /* @__PURE__ */ new Map();
-  const errorTypes = /* @__PURE__ */ new Map();
-  const anyType = createIntrinsicType(1 /* Any */, "any");
-  const autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
-  const wildcardType = createIntrinsicType(1 /* Any */, "any");
-  const errorType = createIntrinsicType(1 /* Any */, "error");
-  const unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
-  const nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
-  const intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
-  const unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
-  const nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
-  const undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
-  const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */);
-  const missingType = createIntrinsicType(32768 /* Undefined */, "undefined");
-  const undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType;
-  const optionalType = createIntrinsicType(32768 /* Undefined */, "undefined");
-  const nullType = createIntrinsicType(65536 /* Null */, "null");
-  const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */);
-  const stringType = createIntrinsicType(4 /* String */, "string");
-  const numberType = createIntrinsicType(8 /* Number */, "number");
-  const bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
-  const falseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
-  const regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
-  const trueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
-  const regularTrueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
+  var tupleTypes = /* @__PURE__ */ new Map();
+  var unionTypes = /* @__PURE__ */ new Map();
+  var intersectionTypes = /* @__PURE__ */ new Map();
+  var stringLiteralTypes = /* @__PURE__ */ new Map();
+  var numberLiteralTypes = /* @__PURE__ */ new Map();
+  var bigIntLiteralTypes = /* @__PURE__ */ new Map();
+  var enumLiteralTypes = /* @__PURE__ */ new Map();
+  var indexedAccessTypes = /* @__PURE__ */ new Map();
+  var templateLiteralTypes = /* @__PURE__ */ new Map();
+  var stringMappingTypes = /* @__PURE__ */ new Map();
+  var substitutionTypes = /* @__PURE__ */ new Map();
+  var subtypeReductionCache = /* @__PURE__ */ new Map();
+  var decoratorContextOverrideTypeCache = /* @__PURE__ */ new Map();
+  var cachedTypes = /* @__PURE__ */ new Map();
+  var evolvingArrayTypes = [];
+  var undefinedProperties = /* @__PURE__ */ new Map();
+  var markerTypes = /* @__PURE__ */ new Set();
+  var unknownSymbol = createSymbol(4 /* Property */, "unknown");
+  var resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
+  var unresolvedSymbols = /* @__PURE__ */ new Map();
+  var errorTypes = /* @__PURE__ */ new Map();
+  var anyType = createIntrinsicType(1 /* Any */, "any");
+  var autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
+  var wildcardType = createIntrinsicType(1 /* Any */, "any");
+  var errorType = createIntrinsicType(1 /* Any */, "error");
+  var unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
+  var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
+  var intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
+  var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
+  var nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
+  var undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
+  var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */);
+  var missingType = createIntrinsicType(32768 /* Undefined */, "undefined");
+  var undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType;
+  var optionalType = createIntrinsicType(32768 /* Undefined */, "undefined");
+  var nullType = createIntrinsicType(65536 /* Null */, "null");
+  var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */);
+  var stringType = createIntrinsicType(4 /* String */, "string");
+  var numberType = createIntrinsicType(8 /* Number */, "number");
+  var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
+  var falseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
+  var regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
+  var trueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
+  var regularTrueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
   trueType.regularType = regularTrueType;
   trueType.freshType = trueType;
   regularTrueType.regularType = regularTrueType;
@@ -43083,26 +43081,26 @@ function createTypeChecker(host) {
   falseType.freshType = falseType;
   regularFalseType.regularType = regularFalseType;
   regularFalseType.freshType = falseType;
-  const booleanType = getUnionType([regularFalseType, regularTrueType]);
-  const esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
-  const voidType = createIntrinsicType(16384 /* Void */, "void");
-  const neverType = createIntrinsicType(131072 /* Never */, "never");
-  const silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
-  const implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
-  const unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
-  const nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
-  const stringOrNumberType = getUnionType([stringType, numberType]);
-  const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
-  const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
-  const numberOrBigIntType = getUnionType([numberType, bigintType]);
-  const templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
-  const numericStringType = getTemplateLiteralType(["", ""], [numberType]);
-  const restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
-  const permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
-  const uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never");
-  const uniqueLiteralMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t, () => "(unique literal mapper)");
-  let outofbandVarianceMarkerHandler;
-  const reportUnreliableMapper = makeFunctionTypeMapper((t) => {
+  var booleanType = getUnionType([regularFalseType, regularTrueType]);
+  var esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
+  var voidType = createIntrinsicType(16384 /* Void */, "void");
+  var neverType = createIntrinsicType(131072 /* Never */, "never");
+  var silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
+  var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
+  var unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
+  var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
+  var stringOrNumberType = getUnionType([stringType, numberType]);
+  var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
+  var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
+  var numberOrBigIntType = getUnionType([numberType, bigintType]);
+  var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
+  var numericStringType = getTemplateLiteralType(["", ""], [numberType]);
+  var restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
+  var permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
+  var uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never");
+  var uniqueLiteralMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t, () => "(unique literal mapper)");
+  var outofbandVarianceMarkerHandler;
+  var reportUnreliableMapper = makeFunctionTypeMapper((t) => {
     if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
       outofbandVarianceMarkerHandler(
         /*onlyUnreliable*/
@@ -43111,7 +43109,7 @@ function createTypeChecker(host) {
     }
     return t;
   }, () => "(unmeasurable reporter)");
-  const reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
+  var reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
     if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
       outofbandVarianceMarkerHandler(
         /*onlyUnreliable*/
@@ -43120,30 +43118,30 @@ function createTypeChecker(host) {
     }
     return t;
   }, () => "(unreliable reporter)");
-  const emptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
-  const emptyJsxObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var emptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var emptyJsxObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
   emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
-  const emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
+  var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
   emptyTypeLiteralSymbol.members = createSymbolTable();
-  const emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
-  const unknownEmptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
-  const unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
-  const emptyGenericType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var unknownEmptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
+  var emptyGenericType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
   emptyGenericType.instantiations = /* @__PURE__ */ new Map();
-  const anyFunctionType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var anyFunctionType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
   anyFunctionType.objectFlags |= 262144 /* NonInferrableType */;
-  const noConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
-  const circularConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
-  const resolvingDefaultType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
-  const markerSuperType = createTypeParameter();
-  const markerSubType = createTypeParameter();
+  var noConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var circularConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var resolvingDefaultType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
+  var markerSuperType = createTypeParameter();
+  var markerSubType = createTypeParameter();
   markerSubType.constraint = markerSuperType;
-  const markerOtherType = createTypeParameter();
-  const markerSuperTypeForCheck = createTypeParameter();
-  const markerSubTypeForCheck = createTypeParameter();
+  var markerOtherType = createTypeParameter();
+  var markerSuperTypeForCheck = createTypeParameter();
+  var markerSubTypeForCheck = createTypeParameter();
   markerSubTypeForCheck.constraint = markerSuperTypeForCheck;
-  const noTypePredicate = createTypePredicate(1 /* Identifier */, "<<unresolved>>", 0, anyType);
-  const anySignature = createSignature(
+  var noTypePredicate = createTypePredicate(1 /* Identifier */, "<<unresolved>>", 0, anyType);
+  var anySignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43154,7 +43152,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const unknownSignature = createSignature(
+  var unknownSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43165,7 +43163,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const resolvingSignature = createSignature(
+  var resolvingSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43176,7 +43174,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const silentNeverSignature = createSignature(
+  var silentNeverSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43187,14 +43185,14 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const enumNumberIndexInfo = createIndexInfo(
+  var enumNumberIndexInfo = createIndexInfo(
     numberType,
     stringType,
     /*isReadonly*/
     true
   );
-  const iterationTypesCache = /* @__PURE__ */ new Map();
-  const noIterationTypes = {
+  var iterationTypesCache = /* @__PURE__ */ new Map();
+  var noIterationTypes = {
     get yieldType() {
       return Debug.fail("Not supported");
     },
@@ -43205,10 +43203,10 @@ function createTypeChecker(host) {
       return Debug.fail("Not supported");
     }
   };
-  const anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
-  const anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
-  const defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
-  const asyncIterationTypesResolver = {
+  var anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
+  var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
+  var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
+  var asyncIterationTypesResolver = {
     iterableCacheKey: "iterationTypesOfAsyncIterable",
     iteratorCacheKey: "iterationTypesOfAsyncIterator",
     iteratorSymbolName: "asyncIterator",
@@ -43221,7 +43219,7 @@ function createTypeChecker(host) {
     mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
     mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property
   };
-  const syncIterationTypesResolver = {
+  var syncIterationTypesResolver = {
     iterableCacheKey: "iterationTypesOfIterable",
     iteratorCacheKey: "iterationTypesOfIterator",
     iteratorSymbolName: "iterator",
@@ -43234,118 +43232,118 @@ function createTypeChecker(host) {
     mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
     mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property
   };
-  let amalgamatedDuplicates;
-  const reverseMappedCache = /* @__PURE__ */ new Map();
-  let inInferTypeForHomomorphicMappedType = false;
-  let ambientModulesCache;
-  let patternAmbientModules;
-  let patternAmbientModuleAugmentations;
-  let globalObjectType;
-  let globalFunctionType;
-  let globalCallableFunctionType;
-  let globalNewableFunctionType;
-  let globalArrayType;
-  let globalReadonlyArrayType;
-  let globalStringType;
-  let globalNumberType;
-  let globalBooleanType;
-  let globalRegExpType;
-  let globalThisType;
-  let anyArrayType;
-  let autoArrayType;
-  let anyReadonlyArrayType;
-  let deferredGlobalNonNullableTypeAlias;
-  let deferredGlobalESSymbolConstructorSymbol;
-  let deferredGlobalESSymbolConstructorTypeSymbol;
-  let deferredGlobalESSymbolType;
-  let deferredGlobalTypedPropertyDescriptorType;
-  let deferredGlobalPromiseType;
-  let deferredGlobalPromiseLikeType;
-  let deferredGlobalPromiseConstructorSymbol;
-  let deferredGlobalPromiseConstructorLikeType;
-  let deferredGlobalIterableType;
-  let deferredGlobalIteratorType;
-  let deferredGlobalIterableIteratorType;
-  let deferredGlobalGeneratorType;
-  let deferredGlobalIteratorYieldResultType;
-  let deferredGlobalIteratorReturnResultType;
-  let deferredGlobalAsyncIterableType;
-  let deferredGlobalAsyncIteratorType;
-  let deferredGlobalAsyncIterableIteratorType;
-  let deferredGlobalAsyncGeneratorType;
-  let deferredGlobalTemplateStringsArrayType;
-  let deferredGlobalImportMetaType;
-  let deferredGlobalImportMetaExpressionType;
-  let deferredGlobalImportCallOptionsType;
-  let deferredGlobalExtractSymbol;
-  let deferredGlobalOmitSymbol;
-  let deferredGlobalAwaitedSymbol;
-  let deferredGlobalBigIntType;
-  let deferredGlobalNaNSymbol;
-  let deferredGlobalRecordSymbol;
-  let deferredGlobalClassDecoratorContextType;
-  let deferredGlobalClassMethodDecoratorContextType;
-  let deferredGlobalClassGetterDecoratorContextType;
-  let deferredGlobalClassSetterDecoratorContextType;
-  let deferredGlobalClassAccessorDecoratorContextType;
-  let deferredGlobalClassAccessorDecoratorTargetType;
-  let deferredGlobalClassAccessorDecoratorResultType;
-  let deferredGlobalClassFieldDecoratorContextType;
-  const allPotentiallyUnusedIdentifiers = /* @__PURE__ */ new Map();
-  let flowLoopStart = 0;
-  let flowLoopCount = 0;
-  let sharedFlowCount = 0;
-  let flowAnalysisDisabled = false;
-  let flowInvocationCount = 0;
-  let lastFlowNode;
-  let lastFlowNodeReachable;
-  let flowTypeCache;
-  const contextualTypeNodes = [];
-  const contextualTypes = [];
-  const contextualIsCache = [];
-  let contextualTypeCount = 0;
-  const inferenceContextNodes = [];
-  const inferenceContexts = [];
-  let inferenceContextCount = 0;
-  const emptyStringType = getStringLiteralType("");
-  const zeroType = getNumberLiteralType(0);
-  const zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
-  const resolutionTargets = [];
-  const resolutionResults = [];
-  const resolutionPropertyNames = [];
-  let suggestionCount = 0;
-  const maximumSuggestionCount = 10;
-  const mergedSymbols = [];
-  const symbolLinks = [];
-  const nodeLinks = [];
-  const flowLoopCaches = [];
-  const flowLoopNodes = [];
-  const flowLoopKeys = [];
-  const flowLoopTypes = [];
-  const sharedFlowNodes = [];
-  const sharedFlowTypes = [];
-  const flowNodeReachable = [];
-  const flowNodePostSuper = [];
-  const potentialThisCollisions = [];
-  const potentialNewTargetCollisions = [];
-  const potentialWeakMapSetCollisions = [];
-  const potentialReflectCollisions = [];
-  const potentialUnusedRenamedBindingElementsInTypes = [];
-  const awaitedTypeStack = [];
-  const diagnostics = createDiagnosticCollection();
-  const suggestionDiagnostics = createDiagnosticCollection();
-  const typeofType = createTypeofType();
-  let _jsxNamespace;
-  let _jsxFactoryEntity;
-  const subtypeRelation = /* @__PURE__ */ new Map();
-  const strictSubtypeRelation = /* @__PURE__ */ new Map();
-  const assignableRelation = /* @__PURE__ */ new Map();
-  const comparableRelation = /* @__PURE__ */ new Map();
-  const identityRelation = /* @__PURE__ */ new Map();
-  const enumRelation = /* @__PURE__ */ new Map();
-  const builtinGlobals = createSymbolTable();
+  var amalgamatedDuplicates;
+  var reverseMappedCache = /* @__PURE__ */ new Map();
+  var inInferTypeForHomomorphicMappedType = false;
+  var ambientModulesCache;
+  var patternAmbientModules;
+  var patternAmbientModuleAugmentations;
+  var globalObjectType;
+  var globalFunctionType;
+  var globalCallableFunctionType;
+  var globalNewableFunctionType;
+  var globalArrayType;
+  var globalReadonlyArrayType;
+  var globalStringType;
+  var globalNumberType;
+  var globalBooleanType;
+  var globalRegExpType;
+  var globalThisType;
+  var anyArrayType;
+  var autoArrayType;
+  var anyReadonlyArrayType;
+  var deferredGlobalNonNullableTypeAlias;
+  var deferredGlobalESSymbolConstructorSymbol;
+  var deferredGlobalESSymbolConstructorTypeSymbol;
+  var deferredGlobalESSymbolType;
+  var deferredGlobalTypedPropertyDescriptorType;
+  var deferredGlobalPromiseType;
+  var deferredGlobalPromiseLikeType;
+  var deferredGlobalPromiseConstructorSymbol;
+  var deferredGlobalPromiseConstructorLikeType;
+  var deferredGlobalIterableType;
+  var deferredGlobalIteratorType;
+  var deferredGlobalIterableIteratorType;
+  var deferredGlobalGeneratorType;
+  var deferredGlobalIteratorYieldResultType;
+  var deferredGlobalIteratorReturnResultType;
+  var deferredGlobalAsyncIterableType;
+  var deferredGlobalAsyncIteratorType;
+  var deferredGlobalAsyncIterableIteratorType;
+  var deferredGlobalAsyncGeneratorType;
+  var deferredGlobalTemplateStringsArrayType;
+  var deferredGlobalImportMetaType;
+  var deferredGlobalImportMetaExpressionType;
+  var deferredGlobalImportCallOptionsType;
+  var deferredGlobalExtractSymbol;
+  var deferredGlobalOmitSymbol;
+  var deferredGlobalAwaitedSymbol;
+  var deferredGlobalBigIntType;
+  var deferredGlobalNaNSymbol;
+  var deferredGlobalRecordSymbol;
+  var deferredGlobalClassDecoratorContextType;
+  var deferredGlobalClassMethodDecoratorContextType;
+  var deferredGlobalClassGetterDecoratorContextType;
+  var deferredGlobalClassSetterDecoratorContextType;
+  var deferredGlobalClassAccessorDecoratorContextType;
+  var deferredGlobalClassAccessorDecoratorTargetType;
+  var deferredGlobalClassAccessorDecoratorResultType;
+  var deferredGlobalClassFieldDecoratorContextType;
+  var allPotentiallyUnusedIdentifiers = /* @__PURE__ */ new Map();
+  var flowLoopStart = 0;
+  var flowLoopCount = 0;
+  var sharedFlowCount = 0;
+  var flowAnalysisDisabled = false;
+  var flowInvocationCount = 0;
+  var lastFlowNode;
+  var lastFlowNodeReachable;
+  var flowTypeCache;
+  var contextualTypeNodes = [];
+  var contextualTypes = [];
+  var contextualIsCache = [];
+  var contextualTypeCount = 0;
+  var inferenceContextNodes = [];
+  var inferenceContexts = [];
+  var inferenceContextCount = 0;
+  var emptyStringType = getStringLiteralType("");
+  var zeroType = getNumberLiteralType(0);
+  var zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
+  var resolutionTargets = [];
+  var resolutionResults = [];
+  var resolutionPropertyNames = [];
+  var suggestionCount = 0;
+  var maximumSuggestionCount = 10;
+  var mergedSymbols = [];
+  var symbolLinks = [];
+  var nodeLinks = [];
+  var flowLoopCaches = [];
+  var flowLoopNodes = [];
+  var flowLoopKeys = [];
+  var flowLoopTypes = [];
+  var sharedFlowNodes = [];
+  var sharedFlowTypes = [];
+  var flowNodeReachable = [];
+  var flowNodePostSuper = [];
+  var potentialThisCollisions = [];
+  var potentialNewTargetCollisions = [];
+  var potentialWeakMapSetCollisions = [];
+  var potentialReflectCollisions = [];
+  var potentialUnusedRenamedBindingElementsInTypes = [];
+  var awaitedTypeStack = [];
+  var diagnostics = createDiagnosticCollection();
+  var suggestionDiagnostics = createDiagnosticCollection();
+  var typeofType = createTypeofType();
+  var _jsxNamespace;
+  var _jsxFactoryEntity;
+  var subtypeRelation = /* @__PURE__ */ new Map();
+  var strictSubtypeRelation = /* @__PURE__ */ new Map();
+  var assignableRelation = /* @__PURE__ */ new Map();
+  var comparableRelation = /* @__PURE__ */ new Map();
+  var identityRelation = /* @__PURE__ */ new Map();
+  var enumRelation = /* @__PURE__ */ new Map();
+  var builtinGlobals = createSymbolTable();
   builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
-  const suggestedExtensions = [
+  var suggestedExtensions = [
     [".mts", ".mjs"],
     [".ts", ".js"],
     [".cts", ".cjs"],
@@ -50496,7 +50494,7 @@ function createTypeChecker(host) {
   }
   function findResolutionCycleStartIndex(target, propertyName) {
     for (let i = resolutionTargets.length - 1; i >= 0; i--) {
-      if (hasType2(resolutionTargets[i], resolutionPropertyNames[i])) {
+      if (resolutionTargetHasProperty(resolutionTargets[i], resolutionPropertyNames[i])) {
         return -1;
       }
       if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
@@ -50505,7 +50503,7 @@ function createTypeChecker(host) {
     }
     return -1;
   }
-  function hasType2(target, propertyName) {
+  function resolutionTargetHasProperty(target, propertyName) {
     switch (propertyName) {
       case 0 /* Type */:
         return !!getSymbolLinks(target).type;
@@ -54510,7 +54508,7 @@ function createTypeChecker(host) {
           const [childTypeParameter = declaration.parent, grandParent] = walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent);
           if (grandParent.kind === 180 /* TypeReference */ && !omitTypeReferences) {
             const typeReference = grandParent;
-            const typeParameters = getTypeParametersForTypeReference(typeReference);
+            const typeParameters = getTypeParametersForTypeReferenceOrImport(typeReference);
             if (typeParameters) {
               const index = typeReference.typeArguments.indexOf(childTypeParameter);
               if (index < typeParameters.length) {
@@ -56913,7 +56911,7 @@ function createTypeChecker(host) {
   }
   function getActualTypeVariable(type) {
     if (type.flags & 33554432 /* Substitution */) {
-      return type.baseType;
+      return getActualTypeVariable(type.baseType);
     }
     if (type.flags & 8388608 /* IndexedAccess */ && (type.objectType.flags & 33554432 /* Substitution */ || type.indexType.flags & 33554432 /* Substitution */)) {
       return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType));
@@ -57173,13 +57171,6 @@ function createTypeChecker(host) {
     if (meaning === 111551 /* Value */) {
       return getInstantiationExpressionType(getTypeOfSymbol(symbol), node);
     } else {
-      const type = tryGetDeclaredTypeOfSymbol(resolvedSymbol);
-      const typeParameters = type && getTypeParametersForTypeAndSymbol(type, resolvedSymbol);
-      if (node.typeArguments && typeParameters) {
-        addLazyDiagnostic(() => {
-          checkTypeArgumentConstraints(node, typeParameters);
-        });
-      }
       return getTypeReferenceType(node, resolvedSymbol);
     }
   }
@@ -59406,7 +59397,7 @@ function createTypeChecker(host) {
             return 0 /* False */;
           }
         }
-        const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (134348796 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures2(source2));
+        const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (134348796 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures(source2));
         const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
         if (isPerformingCommonPropertyChecks && !hasCommonProperties(source2, target2, isComparingJsxAttributes)) {
           if (reportErrors2) {
@@ -62004,7 +61995,7 @@ function createTypeChecker(host) {
   }
   function isObjectTypeWithInferableIndex(type) {
     const objectFlags = getObjectFlags(type);
-    return type.flags & 2097152 /* Intersection */ ? every(type.types, isObjectTypeWithInferableIndex) : !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 && !(type.symbol.flags & 32 /* Class */) && !typeHasCallOrConstructSignatures2(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
+    return type.flags & 2097152 /* Intersection */ ? every(type.types, isObjectTypeWithInferableIndex) : !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 && !(type.symbol.flags & 32 /* Class */) && !typeHasCallOrConstructSignatures(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
   }
   function createSymbolWithType(source, type) {
     const symbol = createSymbol(source.flags, source.escapedName, getCheckFlags(source) & 8 /* Readonly */);
@@ -72449,7 +72440,7 @@ function createTypeChecker(host) {
     if (!isTypeAny(leftType) && allTypesAssignableToKind(leftType, 134348796 /* Primitive */)) {
       error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
     }
-    if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures2(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
+    if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
       error(right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
     }
     return booleanType;
@@ -73896,7 +73887,7 @@ function createTypeChecker(host) {
         error(node.name, Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
       }
     }
-    if ((node.questionToken || isJSDocOptionalParameter(node)) && isBindingPattern(node.name) && func.body) {
+    if (!node.initializer && isOptionalDeclaration(node) && isBindingPattern(node.name) && func.body) {
       error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
     }
     if (node.name && isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
@@ -74418,8 +74409,8 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getTypeParametersForTypeReference(node) {
-    const type = getTypeFromTypeReference(node);
+  function getTypeParametersForTypeReferenceOrImport(node) {
+    const type = getTypeFromTypeNode(node);
     if (!isErrorType(type)) {
       const symbol = getNodeLinks(node).resolvedSymbol;
       if (symbol) {
@@ -74437,11 +74428,14 @@ function createTypeChecker(host) {
       }
     }
     forEach(node.typeArguments, checkSourceElement);
-    const type = getTypeFromTypeReference(node);
+    checkTypeReferenceOrImport(node);
+  }
+  function checkTypeReferenceOrImport(node) {
+    const type = getTypeFromTypeNode(node);
     if (!isErrorType(type)) {
       if (node.typeArguments) {
         addLazyDiagnostic(() => {
-          const typeParameters = getTypeParametersForTypeReference(node);
+          const typeParameters = getTypeParametersForTypeReferenceOrImport(node);
           if (typeParameters) {
             checkTypeArgumentConstraints(node, typeParameters);
           }
@@ -74463,7 +74457,7 @@ function createTypeChecker(host) {
     const typeReferenceNode = tryCast(node.parent, isTypeReferenceType);
     if (!typeReferenceNode)
       return void 0;
-    const typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
+    const typeParameters = getTypeParametersForTypeReferenceOrImport(typeReferenceNode);
     if (!typeParameters)
       return void 0;
     const constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
@@ -74643,7 +74637,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    getTypeFromTypeNode(node);
+    checkTypeReferenceOrImport(node);
   }
   function checkNamedTupleMember(node) {
     if (node.dotDotDotToken && node.questionToken) {
@@ -80120,8 +80114,8 @@ function createTypeChecker(host) {
     }
     return getNamedMembers(propsByName);
   }
-  function typeHasCallOrConstructSignatures2(type) {
-    return typeHasCallOrConstructSignatures(type, checker);
+  function typeHasCallOrConstructSignatures(type) {
+    return getSignaturesOfType(type, 0 /* Call */).length !== 0 || getSignaturesOfType(type, 1 /* Construct */).length !== 0;
   }
   function getRootSymbols(symbol) {
     const roots = getImmediateRootSymbols(symbol);
@@ -115430,7 +115424,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     if (version2 === "6.0" /* v6_0 */) {
       createDiagnostic(Diagnostics.Flag_0_is_deprecated_Please_remove_it_from_your_configuration, value || name);
     } else {
-      createDiagnostic(Diagnostics.Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_ignoreDeprecations_Colon_2_to_silence_this_error, value || name, "5.5" /* v5_5 */, "5.0" /* v5_0 */);
+      createDiagnostic(Diagnostics.Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error, value || name, "5.5" /* v5_5 */, "5.0" /* v5_0 */);
     }
   }
   function createDiagnosticExplainingFile(file, fileProcessingReason, diagnostic, args) {