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

package/lib/tsserver.js

@@ -331,6 +331,7 @@ __export(server_exports, {
   consumesNodeCoreModules: () => consumesNodeCoreModules,
   contains: () => contains,
   containsIgnoredPath: () => containsIgnoredPath,
+  containsObjectRestOrSpread: () => containsObjectRestOrSpread,
   containsParseError: () => containsParseError,
   containsPath: () => containsPath,
   convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry,
@@ -2233,7 +2234,6 @@ __export(server_exports, {
   typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
   typeAliasNamePart: () => typeAliasNamePart,
   typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
-  typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
   typeKeywords: () => typeKeywords,
   typeParameterNamePart: () => typeParameterNamePart,
   typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,
@@ -2288,7 +2288,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230221`;
+var version = `${versionMajorMinor}.0-dev.20230223`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -10360,7 +10360,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}'."),
@@ -14973,7 +14973,7 @@ function isTransientSymbol(symbol) {
 }
 var stringWriter = createSingleLineStringWriter();
 function createSingleLineStringWriter() {
-  let str = "";
+  var str = "";
   const writeText = (text) => str += text;
   return {
     getText: () => str,
@@ -18516,12 +18516,12 @@ function isNightly() {
   return stringContains(version, "-dev") || stringContains(version, "-insiders");
 }
 function createTextWriter(newLine) {
-  let output;
-  let indent3;
-  let lineStart;
-  let lineCount;
-  let linePos;
-  let hasTrailingComment = false;
+  var output;
+  var indent3;
+  var lineStart;
+  var lineCount;
+  var linePos;
+  var hasTrailingComment = false;
   function updateLineCountAndPosFor(s) {
     const lineStartsOfS = computeLineStarts(s);
     if (lineStartsOfS.length > 1) {
@@ -19751,9 +19751,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 forSomeAncestorDirectory(directory, callback) {
   return !!forEachAncestorDirectory(directory, (d) => callback(d) ? true : void 0);
 }
@@ -23989,24 +23986,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;
@@ -29684,6 +29664,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) {
@@ -33946,7 +33945,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();
@@ -43368,35 +43367,36 @@ function bindSourceFile(file, options) {
   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);
   }
@@ -43447,7 +43447,6 @@ function createBinder() {
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
   }
-  return bindSourceFile2;
   function bindInStrictMode(file2, opts) {
     if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
       return true;
@@ -47156,8 +47155,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;
@@ -47168,58 +47167,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 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),
@@ -47596,7 +47595,8 @@ function createTypeChecker(host) {
     isPropertyAccessible,
     getTypeOnlyAliasDeclaration,
     getMemberOverrideModifierStatus,
-    isTypeParameterPossiblyReferenced
+    isTypeParameterPossiblyReferenced,
+    typeHasCallOrConstructSignatures
   };
   function runWithoutResolvedSignatureCaching(node, fn) {
     const containingCall = findAncestor(node, isCallLikeExpression);
@@ -47638,50 +47638,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;
@@ -47690,26 +47690,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*/
@@ -47718,7 +47718,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*/
@@ -47727,30 +47727,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,
@@ -47761,7 +47761,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const unknownSignature = createSignature(
+  var unknownSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -47772,7 +47772,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const resolvingSignature = createSignature(
+  var resolvingSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -47783,7 +47783,7 @@ function createTypeChecker(host) {
     0,
     0 /* None */
   );
-  const silentNeverSignature = createSignature(
+  var silentNeverSignature = createSignature(
     void 0,
     void 0,
     void 0,
@@ -47794,14 +47794,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");
     },
@@ -47812,10 +47812,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",
@@ -47828,7 +47828,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",
@@ -47841,118 +47841,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"],
@@ -55103,7 +55103,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) {
@@ -55112,7 +55112,7 @@ function createTypeChecker(host) {
     }
     return -1;
   }
-  function hasType2(target, propertyName) {
+  function resolutionTargetHasProperty(target, propertyName) {
     switch (propertyName) {
       case 0 /* Type */:
         return !!getSymbolLinks(target).type;
@@ -59117,7 +59117,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) {
@@ -61520,7 +61520,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));
@@ -61780,13 +61780,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);
     }
   }
@@ -64013,7 +64006,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) {
@@ -66611,7 +66604,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 */);
@@ -77056,7 +77049,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;
@@ -78503,7 +78496,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")) {
@@ -79025,8 +79018,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) {
@@ -79044,11 +79037,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);
           }
@@ -79070,7 +79066,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)]);
@@ -79250,7 +79246,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    getTypeFromTypeNode(node);
+    checkTypeReferenceOrImport(node);
   }
   function checkNamedTupleMember(node) {
     if (node.dotDotDotToken && node.questionToken) {
@@ -84727,8 +84723,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);
@@ -88689,31 +88685,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,
@@ -97839,7 +97835,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,
@@ -97971,7 +97967,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);
@@ -111219,15 +111215,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,
@@ -111794,7 +111790,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,
@@ -111806,57 +111802,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();
   reset2();
   return {
     // public API
@@ -120273,7 +120269,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) {
@@ -129593,7 +129589,7 @@ function needsParentheses(expression) {
   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);
@@ -129602,7 +129598,7 @@ function getContextualTypeFromParent(node, checker, contextFlags) {
       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);
   }
@@ -130162,8 +130158,8 @@ function newCaseClauseTracker(checker, clauses) {
   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 */:
@@ -151382,7 +151378,7 @@ function getPropertiesForObjectExpression(contextualType, completionsType, obj,
 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 */));
@@ -151927,7 +151923,7 @@ function getStringLiteralCompletionEntries(sourceFile, node, position, typeCheck
     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:
@@ -158542,12 +158538,7 @@ function filterImport(i, moduleSpecifier, keep) {
       return defaultImport || namedBindings ? factory.createImportDeclaration(
         /*modifiers*/
         void 0,
-        factory.createImportClause(
-          /*isTypeOnly*/
-          false,
-          defaultImport,
-          namedBindings
-        ),
+        factory.createImportClause(clause.isTypeOnly, defaultImport, namedBindings),
         moduleSpecifier,
         /*assertClause*/
         void 0
@@ -167933,6 +167924,7 @@ __export(ts_exports3, {
   consumesNodeCoreModules: () => consumesNodeCoreModules,
   contains: () => contains,
   containsIgnoredPath: () => containsIgnoredPath,
+  containsObjectRestOrSpread: () => containsObjectRestOrSpread,
   containsParseError: () => containsParseError,
   containsPath: () => containsPath,
   convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry,
@@ -169835,7 +169827,6 @@ __export(ts_exports3, {
   typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
   typeAliasNamePart: () => typeAliasNamePart,
   typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
-  typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
   typeKeywords: () => typeKeywords,
   typeParameterNamePart: () => typeParameterNamePart,
   typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,
@@ -181883,6 +181874,7 @@ start(initializeNodeSystem(), require("os").platform());
   consumesNodeCoreModules,
   contains,
   containsIgnoredPath,
+  containsObjectRestOrSpread,
   containsParseError,
   containsPath,
   convertCompilerOptionsForTelemetry,
@@ -183785,7 +183777,6 @@ start(initializeNodeSystem(), require("os").platform());
   typeAcquisitionDeclarations,
   typeAliasNamePart,
   typeDirectiveIsEqualTo,
-  typeHasCallOrConstructSignatures,
   typeKeywords,
   typeParameterNamePart,
   typeReferenceResolutionNameAndModeGetter,