typescript 5.0.0-dev.20230221 → 5.0.0-dev.20230222

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230221`;
+      version = `${versionMajorMinor}.0-dev.20230222`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -8182,7 +8182,7 @@ ${lanes.join("\n")}
         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}'."),
@@ -17490,9 +17490,6 @@ ${lanes.join("\n")}
   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 forSomeAncestorDirectory(directory, callback) {
     return !!forEachAncestorDirectory(directory, (d) => callback(d) ? true : void 0);
   }
@@ -41268,35 +41265,36 @@ ${lanes.join("\n")}
     measure("Bind", "beforeBind", "afterBind");
   }
   function createBinder() {
-    let file;
-    let options;
-    let languageVersion;
-    let parent2;
-    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 Symbol46;
-    let classifiableNames;
-    const unreachableFlow = { flags: 1 /* Unreachable */ };
-    const reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
-    const bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
+    var file;
+    var options;
+    var languageVersion;
+    var parent2;
+    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 Symbol46;
+    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);
     }
@@ -41347,7 +41345,6 @@ ${lanes.join("\n")}
       inAssignmentPattern = false;
       emitFlags = 0 /* None */;
     }
-    return bindSourceFile2;
     function bindInStrictMode(file2, opts) {
       if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
         return true;
@@ -44964,8 +44961,8 @@ ${lanes.join("\n")}
     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;
@@ -44976,58 +44973,58 @@ ${lanes.join("\n")}
       });
       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 Symbol46 = objectAllocator.getSymbolConstructor();
-    const Type27 = objectAllocator.getTypeConstructor();
-    const Signature15 = 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 Symbol46 = objectAllocator.getSymbolConstructor();
+    var Type27 = objectAllocator.getTypeConstructor();
+    var Signature15 = 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),
@@ -45404,7 +45401,8 @@ ${lanes.join("\n")}
       isPropertyAccessible,
       getTypeOnlyAliasDeclaration,
       getMemberOverrideModifierStatus,
-      isTypeParameterPossiblyReferenced
+      isTypeParameterPossiblyReferenced,
+      typeHasCallOrConstructSignatures
     };
     function runWithoutResolvedSignatureCaching(node, fn) {
       const containingCall = findAncestor(node, isCallLikeExpression);
@@ -45446,50 +45444,50 @@ ${lanes.join("\n")}
       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;
@@ -45498,26 +45496,26 @@ ${lanes.join("\n")}
     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*/
@@ -45526,7 +45524,7 @@ ${lanes.join("\n")}
       }
       return t;
     }, () => "(unmeasurable reporter)");
-    const reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
+    var reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
       if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
         outofbandVarianceMarkerHandler(
           /*onlyUnreliable*/
@@ -45535,30 +45533,30 @@ ${lanes.join("\n")}
       }
       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,
@@ -45569,7 +45567,7 @@ ${lanes.join("\n")}
       0,
       0 /* None */
     );
-    const unknownSignature = createSignature(
+    var unknownSignature = createSignature(
       void 0,
       void 0,
       void 0,
@@ -45580,7 +45578,7 @@ ${lanes.join("\n")}
       0,
       0 /* None */
     );
-    const resolvingSignature = createSignature(
+    var resolvingSignature = createSignature(
       void 0,
       void 0,
       void 0,
@@ -45591,7 +45589,7 @@ ${lanes.join("\n")}
       0,
       0 /* None */
     );
-    const silentNeverSignature = createSignature(
+    var silentNeverSignature = createSignature(
       void 0,
       void 0,
       void 0,
@@ -45602,14 +45600,14 @@ ${lanes.join("\n")}
       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");
       },
@@ -45620,10 +45618,10 @@ ${lanes.join("\n")}
         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",
@@ -45636,7 +45634,7 @@ ${lanes.join("\n")}
       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",
@@ -45649,118 +45647,118 @@ ${lanes.join("\n")}
       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"],
@@ -52911,7 +52909,7 @@ ${lanes.join("\n")}
     }
     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) {
@@ -52920,7 +52918,7 @@ ${lanes.join("\n")}
       }
       return -1;
     }
-    function hasType2(target, propertyName) {
+    function resolutionTargetHasProperty(target, propertyName) {
       switch (propertyName) {
         case 0 /* Type */:
           return !!getSymbolLinks(target).type;
@@ -56925,7 +56923,7 @@ ${lanes.join("\n")}
             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) {
@@ -59328,7 +59326,7 @@ ${lanes.join("\n")}
     }
     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));
@@ -59588,13 +59586,6 @@ ${lanes.join("\n")}
       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);
       }
     }
@@ -61821,7 +61812,7 @@ ${lanes.join("\n")}
               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) {
@@ -64419,7 +64410,7 @@ ${lanes.join("\n")}
     }
     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 */);
@@ -74864,7 +74855,7 @@ ${lanes.join("\n")}
       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;
@@ -76311,7 +76302,7 @@ ${lanes.join("\n")}
           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")) {
@@ -76833,8 +76824,8 @@ ${lanes.join("\n")}
       }
       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) {
@@ -76852,11 +76843,14 @@ ${lanes.join("\n")}
         }
       }
       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);
             }
@@ -76878,7 +76872,7 @@ ${lanes.join("\n")}
       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)]);
@@ -77058,7 +77052,7 @@ ${lanes.join("\n")}
           }
         }
       }
-      getTypeFromTypeNode(node);
+      checkTypeReferenceOrImport(node);
     }
     function checkNamedTupleMember(node) {
       if (node.dotDotDotToken && node.questionToken) {
@@ -82535,8 +82529,8 @@ ${lanes.join("\n")}
       }
       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);
@@ -85092,7 +85086,6 @@ ${lanes.join("\n")}
     "src/compiler/checker.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       init_ts_moduleSpecifiers();
       init_ts_performance();
       ambientModuleSymbolRegex = /^".+"$/;
@@ -118290,7 +118283,7 @@ ${lanes.join("\n")}
       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) {
@@ -127891,7 +127884,7 @@ ${lanes.join("\n")}
     return isBinaryExpression(expression) && expression.operatorToken.kind === 27 /* CommaToken */ || isObjectLiteralExpression(expression) || isAsExpression(expression) && isObjectLiteralExpression(expression.expression);
   }
   function getContextualTypeFromParent(node, checker, contextFlags) {
-    const { parent: parent2 } = node;
+    const parent2 = walkUpParenthesizedExpressions(node.parent);
     switch (parent2.kind) {
       case 211 /* NewExpression */:
         return checker.getContextualType(parent2, contextFlags);
@@ -127900,7 +127893,7 @@ ${lanes.join("\n")}
         return isEqualityOperatorKind(operatorToken.kind) ? checker.getTypeAtLocation(node === right ? left : right) : checker.getContextualType(node, contextFlags);
       }
       case 292 /* CaseClause */:
-        return parent2.expression === node ? getSwitchedType(parent2, checker) : void 0;
+        return getSwitchedType(parent2, checker);
       default:
         return checker.getContextualType(node, contextFlags);
     }
@@ -128453,8 +128446,8 @@ ${lanes.join("\n")}
     const existingBigInts = /* @__PURE__ */ new Set();
     for (const clause of clauses) {
       if (!isDefaultClause(clause)) {
-        if (isLiteralExpression(clause.expression)) {
-          const expression = clause.expression;
+        const expression = skipParentheses(clause.expression);
+        if (isLiteralExpression(expression)) {
           switch (expression.kind) {
             case 14 /* NoSubstitutionTemplateLiteral */:
             case 10 /* StringLiteral */:
@@ -150413,7 +150406,7 @@ ${lanes.join("\n")}
   function getApparentProperties(type, node, checker) {
     if (!type.isUnion())
       return type.getApparentProperties();
-    return checker.getAllPossiblePropertiesOfTypes(filter(type.types, (memberType) => !(memberType.flags & 134348796 /* Primitive */ || checker.isArrayLikeType(memberType) || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) || typeHasCallOrConstructSignatures(memberType, checker) || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties()))));
+    return checker.getAllPossiblePropertiesOfTypes(filter(type.types, (memberType) => !(memberType.flags & 134348796 /* Primitive */ || checker.isArrayLikeType(memberType) || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) || checker.typeHasCallOrConstructSignatures(memberType) || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties()))));
   }
   function containsNonPublicProperties(props) {
     return some(props, (p) => !!(getDeclarationModifierFlagsFromSymbol(p) & 24 /* NonPublicAccessibilityModifier */));
@@ -151023,7 +151016,7 @@ ${lanes.join("\n")}
       case 280 /* ExternalModuleReference */:
         return { kind: 0 /* Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };
       case 292 /* CaseClause */:
-        const tracker = newCaseClauseTracker(typeChecker, node.parent.parent.clauses);
+        const tracker = newCaseClauseTracker(typeChecker, parent2.parent.clauses);
         const literals = fromContextualType().types.filter((literal) => !tracker.hasValue(literal.value));
         return { kind: 2 /* Types */, types: literals, isNewIdentifier: false };
       default:
@@ -157761,12 +157754,7 @@ ${lanes.join("\n")}
         return defaultImport || namedBindings ? factory.createImportDeclaration(
           /*modifiers*/
           void 0,
-          factory.createImportClause(
-            /*isTypeOnly*/
-            false,
-            defaultImport,
-            namedBindings
-          ),
+          factory.createImportClause(clause.isTypeOnly, defaultImport, namedBindings),
           moduleSpecifier,
           /*assertClause*/
           void 0
@@ -180421,7 +180409,6 @@ ${e.message}`;
     typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
     typeAliasNamePart: () => typeAliasNamePart,
     typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
-    typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
     typeKeywords: () => typeKeywords,
     typeParameterNamePart: () => typeParameterNamePart,
     typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,
@@ -182781,7 +182768,6 @@ ${e.message}`;
     typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
     typeAliasNamePart: () => typeAliasNamePart,
     typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
-    typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
     typeKeywords: () => typeKeywords,
     typeParameterNamePart: () => typeParameterNamePart,
     typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,