typescript 5.0.0-dev.20230221 → 5.0.0-dev.20230223

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.20230221`;
+var version = `${versionMajorMinor}.0-dev.20230223`;
 
 // 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}'."),
@@ -11329,7 +11329,7 @@ function isTransientSymbol(symbol) {
 }
 var stringWriter = createSingleLineStringWriter();
 function createSingleLineStringWriter() {
-  let str = "";
+  var str = "";
   const writeText = (text) => str += text;
   return {
     getText: () => str,
@@ -14605,12 +14605,12 @@ function isNightly() {
   return stringContains(version, "-dev") || stringContains(version, "-insiders");
 }
 function createTextWriter(newLine) {
-  let output;
-  let indent2;
-  let lineStart;
-  let lineCount;
-  let linePos;
-  let hasTrailingComment = false;
+  var output;
+  var indent2;
+  var lineStart;
+  var lineCount;
+  var linePos;
+  var hasTrailingComment = false;
   function updateLineCountAndPosFor(s) {
     const lineStartsOfS = computeLineStarts(s);
     if (lineStartsOfS.length > 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]);
 }
@@ -19839,24 +19836,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function propagateAssignmentPatternFlags(node) {
-    if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
-      return 65536 /* ContainsObjectRestOrSpread */;
-    if (node.transformFlags & 128 /* ContainsES2018 */) {
-      for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
-        const target = getTargetOfBindingOrAssignmentElement(element);
-        if (target && isAssignmentPattern(target)) {
-          if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
-            return 65536 /* ContainsObjectRestOrSpread */;
-          }
-          if (target.transformFlags & 128 /* ContainsES2018 */) {
-            const flags2 = propagateAssignmentPatternFlags(target);
-            if (flags2)
-              return flags2;
-          }
-        }
-      }
-    }
-    return 0 /* None */;
+    return containsObjectRestOrSpread(node) ? 65536 /* ContainsObjectRestOrSpread */ : 0 /* None */;
   }
   function updateBinaryExpression(node, left, operator, right) {
     return node.left !== left || node.operatorToken !== operator || node.right !== right ? update(createBinaryExpression(left, operator, right), node) : node;
@@ -25353,6 +25333,25 @@ function flattenCommaList(node) {
   flattenCommaListWorker(node, expressions);
   return expressions;
 }
+function containsObjectRestOrSpread(node) {
+  if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
+    return true;
+  if (node.transformFlags & 128 /* ContainsES2018 */) {
+    for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
+      const target = getTargetOfBindingOrAssignmentElement(element);
+      if (target && isAssignmentPattern(target)) {
+        if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
+          return true;
+        }
+        if (target.transformFlags & 128 /* ContainsES2018 */) {
+          if (containsObjectRestOrSpread(target))
+            return true;
+        }
+      }
+    }
+  }
+  return false;
+}
 
 // src/compiler/factory/utilitiesPublic.ts
 function setTextRange(range, location) {
@@ -29600,7 +29599,7 @@ var Parser;
     return finishNode(factory2.createJsxJsxClosingFragment(), pos);
   }
   function parseTypeAssertion() {
-    Debug.assert(scriptKind === 3 /* TS */, "Type assertions should never be parsed outside of TS; they should either be comparisons or JSX.");
+    Debug.assert(languageVariant !== 1 /* JSX */, "Type assertions should never be parsed in JSX; they should be parsed as comparisons or JSX elements/fragments.");
     const pos = getNodePos();
     parseExpected(29 /* LessThanToken */);
     const type = parseType();
@@ -38809,35 +38808,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 +38888,6 @@ function createBinder() {
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
   }
-  return bindSourceFile2;
   function bindInStrictMode(file2, opts) {
     if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
       return true;
@@ -42549,8 +42548,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 +42560,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 +42988,8 @@ function createTypeChecker(host) {
     isPropertyAccessible,
     getTypeOnlyAliasDeclaration,
     getMemberOverrideModifierStatus,
-    isTypeParameterPossiblyReferenced
+    isTypeParameterPossiblyReferenced,
+    typeHasCallOrConstructSignatures
   };
   function runWithoutResolvedSignatureCaching(node, fn) {
     const containingCall = findAncestor(node, isCallLikeExpression);
@@ -43031,50 +43031,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 +43083,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 +43111,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 +43120,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 +43154,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const unknownSignature = createSignature(
+  var unknownSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43165,7 +43165,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const resolvingSignature = createSignature(
+  var resolvingSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43176,7 +43176,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const silentNeverSignature = createSignature(
+  var silentNeverSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -43187,14 +43187,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 +43205,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 +43221,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 +43234,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 +50496,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 +50505,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 +54510,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 +56913,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 +57173,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 +59399,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 +61997,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 +72442,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 +73889,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 +74411,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 +74430,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 +74459,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 +74639,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    getTypeFromTypeNode(node);
+    checkTypeReferenceOrImport(node);
   }
   function checkNamedTupleMember(node) {
     if (node.dotDotDotToken && node.questionToken) {
@@ -80120,8 +80116,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);
@@ -84082,31 +84078,31 @@ function extractSingleNode(nodes) {
 
 // src/compiler/sourcemap.ts
 function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) {
-  const { enter, exit } = generatorOptions.extendedDiagnostics ? createTimer("Source Map", "beforeSourcemap", "afterSourcemap") : nullTimer;
-  const rawSources = [];
-  const sources = [];
-  const sourceToSourceIndexMap = /* @__PURE__ */ new Map();
-  let sourcesContent;
-  const names = [];
-  let nameToNameIndexMap;
-  const mappingCharCodes = [];
-  let mappings = "";
-  let lastGeneratedLine = 0;
-  let lastGeneratedCharacter = 0;
-  let lastSourceIndex = 0;
-  let lastSourceLine = 0;
-  let lastSourceCharacter = 0;
-  let lastNameIndex = 0;
-  let hasLast = false;
-  let pendingGeneratedLine = 0;
-  let pendingGeneratedCharacter = 0;
-  let pendingSourceIndex = 0;
-  let pendingSourceLine = 0;
-  let pendingSourceCharacter = 0;
-  let pendingNameIndex = 0;
-  let hasPending = false;
-  let hasPendingSource = false;
-  let hasPendingName = false;
+  var { enter, exit } = generatorOptions.extendedDiagnostics ? createTimer("Source Map", "beforeSourcemap", "afterSourcemap") : nullTimer;
+  var rawSources = [];
+  var sources = [];
+  var sourceToSourceIndexMap = /* @__PURE__ */ new Map();
+  var sourcesContent;
+  var names = [];
+  var nameToNameIndexMap;
+  var mappingCharCodes = [];
+  var mappings = "";
+  var lastGeneratedLine = 0;
+  var lastGeneratedCharacter = 0;
+  var lastSourceIndex = 0;
+  var lastSourceLine = 0;
+  var lastSourceCharacter = 0;
+  var lastNameIndex = 0;
+  var hasLast = false;
+  var pendingGeneratedLine = 0;
+  var pendingGeneratedCharacter = 0;
+  var pendingSourceIndex = 0;
+  var pendingSourceLine = 0;
+  var pendingSourceCharacter = 0;
+  var pendingNameIndex = 0;
+  var hasPending = false;
+  var hasPendingSource = false;
+  var hasPendingName = false;
   return {
     getSources: () => rawSources,
     addSource,
@@ -93061,7 +93057,7 @@ function transformES2018(context) {
     );
   }
   function visitBinaryExpression(node, expressionResultIsUnused2) {
-    if (isDestructuringAssignment(node) && node.left.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
+    if (isDestructuringAssignment(node) && containsObjectRestOrSpread(node.left)) {
       return flattenDestructuringAssignment(
         node,
         visitor,
@@ -93193,7 +93189,7 @@ function transformES2018(context) {
   }
   function visitForOfStatement(node, outermostLabeledStatement) {
     const ancestorFacts = enterSubtree(0 /* IterationStatementExcludes */, 2 /* IterationStatementIncludes */);
-    if (node.initializer.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
+    if (node.initializer.transformFlags & 65536 /* ContainsObjectRestOrSpread */ || isAssignmentPattern(node.initializer) && containsObjectRestOrSpread(node.initializer)) {
       node = transformForOfStatementWithObjectRest(node);
     }
     const result = node.awaitModifier ? transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) : factory2.restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement);
@@ -106430,15 +106426,15 @@ function getFirstProjectOutput(configFile, ignoreCase) {
   return Debug.fail(`project ${configFile.options.configFilePath} expected to have at least one output`);
 }
 function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, declarationTransformers }, emitOnly, onlyBuildInfo, forceDtsEmit) {
-  const compilerOptions = host.getCompilerOptions();
-  const sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
-  const emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
-  const emitterDiagnostics = createDiagnosticCollection();
-  const newLine = getNewLineCharacter(compilerOptions);
-  const writer = createTextWriter(newLine);
-  const { enter, exit } = createTimer("printTime", "beforePrint", "afterPrint");
-  let bundleBuildInfo;
-  let emitSkipped = false;
+  var compilerOptions = host.getCompilerOptions();
+  var sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
+  var emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
+  var emitterDiagnostics = createDiagnosticCollection();
+  var newLine = getNewLineCharacter(compilerOptions);
+  var writer = createTextWriter(newLine);
+  var { enter, exit } = createTimer("printTime", "beforePrint", "afterPrint");
+  var bundleBuildInfo;
+  var emitSkipped = false;
   enter();
   forEachEmittedFile(
     host,
@@ -107005,7 +107001,7 @@ var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinte
 var createPrinterWithRemoveCommentsNeverAsciiEscape = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, neverAsciiEscape: true }));
 var createPrinterWithRemoveCommentsOmitTrailingSemicolon = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, omitTrailingSemicolon: true }));
 function createPrinter(printerOptions = {}, handlers = {}) {
-  const {
+  var {
     hasGlobalName,
     onEmitNode = noEmitNotification,
     isEmitNotificationEnabled,
@@ -107017,57 +107013,57 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     onBeforeEmitToken,
     onAfterEmitToken
   } = handlers;
-  const extendedDiagnostics = !!printerOptions.extendedDiagnostics;
-  const newLine = getNewLineCharacter(printerOptions);
-  const moduleKind = getEmitModuleKind(printerOptions);
-  const bundledHelpers = /* @__PURE__ */ new Map();
-  let currentSourceFile;
-  let nodeIdToGeneratedName;
-  let nodeIdToGeneratedPrivateName;
-  let autoGeneratedIdToGeneratedName;
-  let generatedNames;
-  let formattedNameTempFlagsStack;
-  let formattedNameTempFlags;
-  let privateNameTempFlagsStack;
-  let privateNameTempFlags;
-  let tempFlagsStack;
-  let tempFlags;
-  let reservedNamesStack;
-  let reservedNames;
-  let reservedPrivateNamesStack;
-  let reservedPrivateNames;
-  let preserveSourceNewlines = printerOptions.preserveSourceNewlines;
-  let nextListElementPos;
-  let writer;
-  let ownWriter;
-  let write = writeBase;
-  let isOwnFileEmit;
-  const bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : void 0;
-  const relativeToBuildInfo = bundleFileInfo ? Debug.checkDefined(printerOptions.relativeToBuildInfo) : void 0;
-  const recordInternalSection = printerOptions.recordInternalSection;
-  let sourceFileTextPos = 0;
-  let sourceFileTextKind = "text" /* Text */;
-  let sourceMapsDisabled = true;
-  let sourceMapGenerator;
-  let sourceMapSource;
-  let sourceMapSourceIndex = -1;
-  let mostRecentlyAddedSourceMapSource;
-  let mostRecentlyAddedSourceMapSourceIndex = -1;
-  let containerPos = -1;
-  let containerEnd = -1;
-  let declarationListContainerEnd = -1;
-  let currentLineMap;
-  let detachedCommentsInfo;
-  let hasWrittenComment = false;
-  let commentsDisabled = !!printerOptions.removeComments;
-  let lastSubstitution;
-  let currentParenthesizerRule;
-  const { enter: enterComment, exit: exitComment } = createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
-  const parenthesizer = factory.parenthesizer;
-  const typeArgumentParenthesizerRuleSelector = {
+  var extendedDiagnostics = !!printerOptions.extendedDiagnostics;
+  var newLine = getNewLineCharacter(printerOptions);
+  var moduleKind = getEmitModuleKind(printerOptions);
+  var bundledHelpers = /* @__PURE__ */ new Map();
+  var currentSourceFile;
+  var nodeIdToGeneratedName;
+  var nodeIdToGeneratedPrivateName;
+  var autoGeneratedIdToGeneratedName;
+  var generatedNames;
+  var formattedNameTempFlagsStack;
+  var formattedNameTempFlags;
+  var privateNameTempFlagsStack;
+  var privateNameTempFlags;
+  var tempFlagsStack;
+  var tempFlags;
+  var reservedNamesStack;
+  var reservedNames;
+  var reservedPrivateNamesStack;
+  var reservedPrivateNames;
+  var preserveSourceNewlines = printerOptions.preserveSourceNewlines;
+  var nextListElementPos;
+  var writer;
+  var ownWriter;
+  var write = writeBase;
+  var isOwnFileEmit;
+  var bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : void 0;
+  var relativeToBuildInfo = bundleFileInfo ? Debug.checkDefined(printerOptions.relativeToBuildInfo) : void 0;
+  var recordInternalSection = printerOptions.recordInternalSection;
+  var sourceFileTextPos = 0;
+  var sourceFileTextKind = "text" /* Text */;
+  var sourceMapsDisabled = true;
+  var sourceMapGenerator;
+  var sourceMapSource;
+  var sourceMapSourceIndex = -1;
+  var mostRecentlyAddedSourceMapSource;
+  var mostRecentlyAddedSourceMapSourceIndex = -1;
+  var containerPos = -1;
+  var containerEnd = -1;
+  var declarationListContainerEnd = -1;
+  var currentLineMap;
+  var detachedCommentsInfo;
+  var hasWrittenComment = false;
+  var commentsDisabled = !!printerOptions.removeComments;
+  var lastSubstitution;
+  var currentParenthesizerRule;
+  var { enter: enterComment, exit: exitComment } = createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
+  var parenthesizer = factory.parenthesizer;
+  var typeArgumentParenthesizerRuleSelector = {
     select: (index) => index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : void 0
   };
-  const emitBinaryExpression = createEmitBinaryExpression();
+  var emitBinaryExpression = createEmitBinaryExpression();
   reset();
   return {
     // public API
@@ -115430,7 +115426,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) {