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

package/lib/typescript.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.20230223`;
       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}'."),
@@ -12806,7 +12806,7 @@ ${lanes.join("\n")}
     return (symbol.flags & 33554432 /* Transient */) !== 0;
   }
   function createSingleLineStringWriter() {
-    let str = "";
+    var str = "";
     const writeText = (text) => str += text;
     return {
       getText: () => str,
@@ -16258,12 +16258,12 @@ ${lanes.join("\n")}
     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) {
@@ -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);
   }
@@ -21843,24 +21840,7 @@ ${lanes.join("\n")}
       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;
@@ -27460,6 +27440,25 @@ ${lanes.join("\n")}
     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;
+  }
   var BinaryExpressionState, BinaryExpressionStateMachine;
   var init_utilities2 = __esm({
     "src/compiler/factory/utilities.ts"() {
@@ -32056,7 +32055,7 @@ ${lanes.join("\n")}
           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();
@@ -41268,35 +41267,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 +41347,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 +44963,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 +44975,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 +45403,8 @@ ${lanes.join("\n")}
       isPropertyAccessible,
       getTypeOnlyAliasDeclaration,
       getMemberOverrideModifierStatus,
-      isTypeParameterPossiblyReferenced
+      isTypeParameterPossiblyReferenced,
+      typeHasCallOrConstructSignatures
     };
     function runWithoutResolvedSignatureCaching(node, fn) {
       const containingCall = findAncestor(node, isCallLikeExpression);
@@ -45446,50 +45446,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 +45498,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 +45526,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 +45535,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 +45569,7 @@ ${lanes.join("\n")}
       0,
       0 /* None */
     );
-    const unknownSignature = createSignature(
+    var unknownSignature = createSignature(
       void 0,
       void 0,
       void 0,
@@ -45580,7 +45580,7 @@ ${lanes.join("\n")}
       0,
       0 /* None */
     );
-    const resolvingSignature = createSignature(
+    var resolvingSignature = createSignature(
       void 0,
       void 0,
       void 0,
@@ -45591,7 +45591,7 @@ ${lanes.join("\n")}
       0,
       0 /* None */
     );
-    const silentNeverSignature = createSignature(
+    var silentNeverSignature = createSignature(
       void 0,
       void 0,
       void 0,
@@ -45602,14 +45602,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 +45620,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 +45636,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 +45649,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 +52911,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 +52920,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 +56925,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 +59328,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 +59588,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 +61814,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 +64412,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 +74857,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 +76304,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 +76826,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 +76845,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 +76874,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 +77054,7 @@ ${lanes.join("\n")}
           }
         }
       }
-      getTypeFromTypeNode(node);
+      checkTypeReferenceOrImport(node);
     }
     function checkNamedTupleMember(node) {
       if (node.dotDotDotToken && node.questionToken) {
@@ -82535,8 +82531,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 +85088,6 @@ ${lanes.join("\n")}
     "src/compiler/checker.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       init_ts_moduleSpecifiers();
       init_ts_performance();
       ambientModuleSymbolRegex = /^".+"$/;
@@ -86638,31 +86633,31 @@ ${lanes.join("\n")}
 
   // 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,
@@ -95853,7 +95848,7 @@ ${lanes.join("\n")}
       );
     }
     function visitBinaryExpression(node, expressionResultIsUnused2) {
-      if (isDestructuringAssignment(node) && node.left.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
+      if (isDestructuringAssignment(node) && containsObjectRestOrSpread(node.left)) {
         return flattenDestructuringAssignment(
           node,
           visitor,
@@ -95985,7 +95980,7 @@ ${lanes.join("\n")}
     }
     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);
@@ -109340,15 +109335,15 @@ ${lanes.join("\n")}
     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,
@@ -109868,7 +109863,7 @@ ${lanes.join("\n")}
     return outputFiles;
   }
   function createPrinter(printerOptions = {}, handlers = {}) {
-    const {
+    var {
       hasGlobalName,
       onEmitNode = noEmitNotification,
       isEmitNotificationEnabled,
@@ -109880,57 +109875,57 @@ ${lanes.join("\n")}
       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();
     reset2();
     return {
       // public API
@@ -118290,7 +118285,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) {
@@ -127905,7 +127900,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);
@@ -127914,7 +127909,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);
     }
@@ -128467,8 +128462,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 */:
@@ -150427,7 +150422,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 */));
@@ -151037,7 +151032,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:
@@ -157775,12 +157770,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
@@ -167700,6 +167690,7 @@ ${options.prefix}` : "\n" : options.prefix
     consumesNodeCoreModules: () => consumesNodeCoreModules,
     contains: () => contains,
     containsIgnoredPath: () => containsIgnoredPath,
+    containsObjectRestOrSpread: () => containsObjectRestOrSpread,
     containsParseError: () => containsParseError,
     containsPath: () => containsPath,
     convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry,
@@ -169602,7 +169593,6 @@ ${options.prefix}` : "\n" : options.prefix
     typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
     typeAliasNamePart: () => typeAliasNamePart,
     typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
-    typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
     typeKeywords: () => typeKeywords,
     typeParameterNamePart: () => typeParameterNamePart,
     typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,