@typescript-deploys/pr-build 5.0.0-pr-49107-5 → 5.0.0-pr-52899-2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/tsc.js CHANGED
@@ -23,7 +23,7 @@ var __export = (target, all) => {
23
23
 
24
24
  // src/compiler/corePublic.ts
25
25
  var versionMajorMinor = "5.0";
26
- var version = `${versionMajorMinor}.0-insiders.20230221`;
26
+ var version = `${versionMajorMinor}.0-insiders.20230223`;
27
27
 
28
28
  // src/compiler/core.ts
29
29
  var emptyArray = [];
@@ -6896,7 +6896,7 @@ var Diagnostics = {
6896
6896
  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'."),
6897
6897
  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.`),
6898
6898
  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."),
6899
- 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.`),
6899
+ 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.`),
6900
6900
  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."),
6901
6901
  Invalid_value_for_ignoreDeprecations: diag(5103, 1 /* Error */, "Invalid_value_for_ignoreDeprecations_5103", "Invalid value for '--ignoreDeprecations'."),
6902
6902
  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}'."),
@@ -7825,7 +7825,8 @@ var Diagnostics = {
7825
7825
  _0_is_possibly_undefined: diag(18048, 1 /* Error */, "_0_is_possibly_undefined_18048", "'{0}' is possibly 'undefined'."),
7826
7826
  _0_is_possibly_null_or_undefined: diag(18049, 1 /* Error */, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."),
7827
7827
  The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."),
7828
- Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string.")
7828
+ Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."),
7829
+ Add_missing_comma_for_an_object_member_completion_0: diag(18052, 3 /* Message */, "Add_missing_comma_for_an_object_member_completion_0_18052", "Add missing comma for an object member completion '{0}'.")
7829
7830
  };
7830
7831
 
7831
7832
  // src/compiler/scanner.ts
@@ -11329,7 +11330,7 @@ function isTransientSymbol(symbol) {
11329
11330
  }
11330
11331
  var stringWriter = createSingleLineStringWriter();
11331
11332
  function createSingleLineStringWriter() {
11332
- let str = "";
11333
+ var str = "";
11333
11334
  const writeText = (text) => str += text;
11334
11335
  return {
11335
11336
  getText: () => str,
@@ -14605,12 +14606,12 @@ function isNightly() {
14605
14606
  return stringContains(version, "-dev") || stringContains(version, "-insiders");
14606
14607
  }
14607
14608
  function createTextWriter(newLine) {
14608
- let output;
14609
- let indent2;
14610
- let lineStart;
14611
- let lineCount;
14612
- let linePos;
14613
- let hasTrailingComment = false;
14609
+ var output;
14610
+ var indent2;
14611
+ var lineStart;
14612
+ var lineCount;
14613
+ var linePos;
14614
+ var hasTrailingComment = false;
14614
14615
  function updateLineCountAndPosFor(s) {
14615
14616
  const lineStartsOfS = computeLineStarts(s);
14616
14617
  if (lineStartsOfS.length > 1) {
@@ -19836,24 +19837,7 @@ function createNodeFactory(flags, baseFactory2) {
19836
19837
  return node;
19837
19838
  }
19838
19839
  function propagateAssignmentPatternFlags(node) {
19839
- if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
19840
- return 65536 /* ContainsObjectRestOrSpread */;
19841
- if (node.transformFlags & 128 /* ContainsES2018 */) {
19842
- for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
19843
- const target = getTargetOfBindingOrAssignmentElement(element);
19844
- if (target && isAssignmentPattern(target)) {
19845
- if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
19846
- return 65536 /* ContainsObjectRestOrSpread */;
19847
- }
19848
- if (target.transformFlags & 128 /* ContainsES2018 */) {
19849
- const flags2 = propagateAssignmentPatternFlags(target);
19850
- if (flags2)
19851
- return flags2;
19852
- }
19853
- }
19854
- }
19855
- }
19856
- return 0 /* None */;
19840
+ return containsObjectRestOrSpread(node) ? 65536 /* ContainsObjectRestOrSpread */ : 0 /* None */;
19857
19841
  }
19858
19842
  function updateBinaryExpression(node, left, operator, right) {
19859
19843
  return node.left !== left || node.operatorToken !== operator || node.right !== right ? update(createBinaryExpression(left, operator, right), node) : node;
@@ -25350,6 +25334,25 @@ function flattenCommaList(node) {
25350
25334
  flattenCommaListWorker(node, expressions);
25351
25335
  return expressions;
25352
25336
  }
25337
+ function containsObjectRestOrSpread(node) {
25338
+ if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
25339
+ return true;
25340
+ if (node.transformFlags & 128 /* ContainsES2018 */) {
25341
+ for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
25342
+ const target = getTargetOfBindingOrAssignmentElement(element);
25343
+ if (target && isAssignmentPattern(target)) {
25344
+ if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
25345
+ return true;
25346
+ }
25347
+ if (target.transformFlags & 128 /* ContainsES2018 */) {
25348
+ if (containsObjectRestOrSpread(target))
25349
+ return true;
25350
+ }
25351
+ }
25352
+ }
25353
+ }
25354
+ return false;
25355
+ }
25353
25356
 
25354
25357
  // src/compiler/factory/utilitiesPublic.ts
25355
25358
  function setTextRange(range, location) {
@@ -29597,7 +29600,7 @@ var Parser;
29597
29600
  return finishNode(factory2.createJsxJsxClosingFragment(), pos);
29598
29601
  }
29599
29602
  function parseTypeAssertion() {
29600
- Debug.assert(scriptKind === 3 /* TS */, "Type assertions should never be parsed outside of TS; they should either be comparisons or JSX.");
29603
+ Debug.assert(languageVariant !== 1 /* JSX */, "Type assertions should never be parsed in JSX; they should be parsed as comparisons or JSX elements/fragments.");
29601
29604
  const pos = getNodePos();
29602
29605
  parseExpected(29 /* LessThanToken */);
29603
29606
  const type = parseType();
@@ -38806,35 +38809,36 @@ function bindSourceFile(file, options) {
38806
38809
  measure("Bind", "beforeBind", "afterBind");
38807
38810
  }
38808
38811
  function createBinder() {
38809
- let file;
38810
- let options;
38811
- let languageVersion;
38812
- let parent;
38813
- let container;
38814
- let thisParentContainer;
38815
- let blockScopeContainer;
38816
- let lastContainer;
38817
- let delayedTypeAliases;
38818
- let seenThisKeyword;
38819
- let currentFlow;
38820
- let currentBreakTarget;
38821
- let currentContinueTarget;
38822
- let currentReturnTarget;
38823
- let currentTrueTarget;
38824
- let currentFalseTarget;
38825
- let currentExceptionTarget;
38826
- let preSwitchCaseFlow;
38827
- let activeLabelList;
38828
- let hasExplicitReturn;
38829
- let emitFlags;
38830
- let inStrictMode;
38831
- let inAssignmentPattern = false;
38832
- let symbolCount = 0;
38833
- let Symbol12;
38834
- let classifiableNames;
38835
- const unreachableFlow = { flags: 1 /* Unreachable */ };
38836
- const reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
38837
- const bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
38812
+ var file;
38813
+ var options;
38814
+ var languageVersion;
38815
+ var parent;
38816
+ var container;
38817
+ var thisParentContainer;
38818
+ var blockScopeContainer;
38819
+ var lastContainer;
38820
+ var delayedTypeAliases;
38821
+ var seenThisKeyword;
38822
+ var currentFlow;
38823
+ var currentBreakTarget;
38824
+ var currentContinueTarget;
38825
+ var currentReturnTarget;
38826
+ var currentTrueTarget;
38827
+ var currentFalseTarget;
38828
+ var currentExceptionTarget;
38829
+ var preSwitchCaseFlow;
38830
+ var activeLabelList;
38831
+ var hasExplicitReturn;
38832
+ var emitFlags;
38833
+ var inStrictMode;
38834
+ var inAssignmentPattern = false;
38835
+ var symbolCount = 0;
38836
+ var Symbol12;
38837
+ var classifiableNames;
38838
+ var unreachableFlow = { flags: 1 /* Unreachable */ };
38839
+ var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
38840
+ var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
38841
+ return bindSourceFile2;
38838
38842
  function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
38839
38843
  return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
38840
38844
  }
@@ -38885,7 +38889,6 @@ function createBinder() {
38885
38889
  inAssignmentPattern = false;
38886
38890
  emitFlags = 0 /* None */;
38887
38891
  }
38888
- return bindSourceFile2;
38889
38892
  function bindInStrictMode(file2, opts) {
38890
38893
  if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
38891
38894
  return true;
@@ -42546,8 +42549,8 @@ function isInstantiatedModule(node, preserveConstEnums) {
42546
42549
  return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
42547
42550
  }
42548
42551
  function createTypeChecker(host) {
42549
- const getPackagesMap = memoize(() => {
42550
- const map2 = /* @__PURE__ */ new Map();
42552
+ var getPackagesMap = memoize(() => {
42553
+ var map2 = /* @__PURE__ */ new Map();
42551
42554
  host.getSourceFiles().forEach((sf) => {
42552
42555
  if (!sf.resolvedModules)
42553
42556
  return;
@@ -42558,58 +42561,58 @@ function createTypeChecker(host) {
42558
42561
  });
42559
42562
  return map2;
42560
42563
  });
42561
- let deferredDiagnosticsCallbacks = [];
42562
- let addLazyDiagnostic = (arg) => {
42564
+ var deferredDiagnosticsCallbacks = [];
42565
+ var addLazyDiagnostic = (arg) => {
42563
42566
  deferredDiagnosticsCallbacks.push(arg);
42564
42567
  };
42565
- let cancellationToken;
42566
- const requestedExternalEmitHelperNames = /* @__PURE__ */ new Set();
42567
- let requestedExternalEmitHelpers;
42568
- let externalHelpersModule;
42569
- const Symbol12 = objectAllocator.getSymbolConstructor();
42570
- const Type7 = objectAllocator.getTypeConstructor();
42571
- const Signature5 = objectAllocator.getSignatureConstructor();
42572
- let typeCount = 0;
42573
- let symbolCount = 0;
42574
- let totalInstantiationCount = 0;
42575
- let instantiationCount = 0;
42576
- let instantiationDepth = 0;
42577
- let inlineLevel = 0;
42578
- let currentNode;
42579
- let varianceTypeParameter;
42580
- let isInferencePartiallyBlocked = false;
42581
- const emptySymbols = createSymbolTable();
42582
- const arrayVariances = [1 /* Covariant */];
42583
- const compilerOptions = host.getCompilerOptions();
42584
- const languageVersion = getEmitScriptTarget(compilerOptions);
42585
- const moduleKind = getEmitModuleKind(compilerOptions);
42586
- const legacyDecorators = !!compilerOptions.experimentalDecorators;
42587
- const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
42588
- const allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
42589
- const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
42590
- const strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
42591
- const strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
42592
- const strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
42593
- const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
42594
- const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
42595
- const useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
42596
- const keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
42597
- const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
42598
- const exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
42599
- const checkBinaryExpression = createCheckBinaryExpression();
42600
- const emitResolver = createResolver();
42601
- const nodeBuilder = createNodeBuilder();
42602
- const globals = createSymbolTable();
42603
- const undefinedSymbol = createSymbol(4 /* Property */, "undefined");
42568
+ var cancellationToken;
42569
+ var requestedExternalEmitHelperNames = /* @__PURE__ */ new Set();
42570
+ var requestedExternalEmitHelpers;
42571
+ var externalHelpersModule;
42572
+ var Symbol12 = objectAllocator.getSymbolConstructor();
42573
+ var Type7 = objectAllocator.getTypeConstructor();
42574
+ var Signature5 = objectAllocator.getSignatureConstructor();
42575
+ var typeCount = 0;
42576
+ var symbolCount = 0;
42577
+ var totalInstantiationCount = 0;
42578
+ var instantiationCount = 0;
42579
+ var instantiationDepth = 0;
42580
+ var inlineLevel = 0;
42581
+ var currentNode;
42582
+ var varianceTypeParameter;
42583
+ var isInferencePartiallyBlocked = false;
42584
+ var emptySymbols = createSymbolTable();
42585
+ var arrayVariances = [1 /* Covariant */];
42586
+ var compilerOptions = host.getCompilerOptions();
42587
+ var languageVersion = getEmitScriptTarget(compilerOptions);
42588
+ var moduleKind = getEmitModuleKind(compilerOptions);
42589
+ var legacyDecorators = !!compilerOptions.experimentalDecorators;
42590
+ var useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
42591
+ var allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
42592
+ var strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
42593
+ var strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
42594
+ var strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
42595
+ var strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
42596
+ var noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
42597
+ var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
42598
+ var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
42599
+ var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
42600
+ var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
42601
+ var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
42602
+ var checkBinaryExpression = createCheckBinaryExpression();
42603
+ var emitResolver = createResolver();
42604
+ var nodeBuilder = createNodeBuilder();
42605
+ var globals = createSymbolTable();
42606
+ var undefinedSymbol = createSymbol(4 /* Property */, "undefined");
42604
42607
  undefinedSymbol.declarations = [];
42605
- const globalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */);
42608
+ var globalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */);
42606
42609
  globalThisSymbol.exports = globals;
42607
42610
  globalThisSymbol.declarations = [];
42608
42611
  globals.set(globalThisSymbol.escapedName, globalThisSymbol);
42609
- const argumentsSymbol = createSymbol(4 /* Property */, "arguments");
42610
- const requireSymbol = createSymbol(4 /* Property */, "require");
42611
- const isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
42612
- let apparentArgumentCount;
42612
+ var argumentsSymbol = createSymbol(4 /* Property */, "arguments");
42613
+ var requireSymbol = createSymbol(4 /* Property */, "require");
42614
+ var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
42615
+ var apparentArgumentCount;
42613
42616
  const checker = {
42614
42617
  getNodeCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.nodeCount, 0),
42615
42618
  getIdentifierCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.identifierCount, 0),
@@ -43029,50 +43032,50 @@ function createTypeChecker(host) {
43029
43032
  apparentArgumentCount = void 0;
43030
43033
  return res;
43031
43034
  }
43032
- const tupleTypes = /* @__PURE__ */ new Map();
43033
- const unionTypes = /* @__PURE__ */ new Map();
43034
- const intersectionTypes = /* @__PURE__ */ new Map();
43035
- const stringLiteralTypes = /* @__PURE__ */ new Map();
43036
- const numberLiteralTypes = /* @__PURE__ */ new Map();
43037
- const bigIntLiteralTypes = /* @__PURE__ */ new Map();
43038
- const enumLiteralTypes = /* @__PURE__ */ new Map();
43039
- const indexedAccessTypes = /* @__PURE__ */ new Map();
43040
- const templateLiteralTypes = /* @__PURE__ */ new Map();
43041
- const stringMappingTypes = /* @__PURE__ */ new Map();
43042
- const substitutionTypes = /* @__PURE__ */ new Map();
43043
- const subtypeReductionCache = /* @__PURE__ */ new Map();
43044
- const decoratorContextOverrideTypeCache = /* @__PURE__ */ new Map();
43045
- const cachedTypes = /* @__PURE__ */ new Map();
43046
- const evolvingArrayTypes = [];
43047
- const undefinedProperties = /* @__PURE__ */ new Map();
43048
- const markerTypes = /* @__PURE__ */ new Set();
43049
- const unknownSymbol = createSymbol(4 /* Property */, "unknown");
43050
- const resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
43051
- const unresolvedSymbols = /* @__PURE__ */ new Map();
43052
- const errorTypes = /* @__PURE__ */ new Map();
43053
- const anyType = createIntrinsicType(1 /* Any */, "any");
43054
- const autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
43055
- const wildcardType = createIntrinsicType(1 /* Any */, "any");
43056
- const errorType = createIntrinsicType(1 /* Any */, "error");
43057
- const unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
43058
- const nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
43059
- const intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
43060
- const unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
43061
- const nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
43062
- const undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
43063
- const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */);
43064
- const missingType = createIntrinsicType(32768 /* Undefined */, "undefined");
43065
- const undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType;
43066
- const optionalType = createIntrinsicType(32768 /* Undefined */, "undefined");
43067
- const nullType = createIntrinsicType(65536 /* Null */, "null");
43068
- const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */);
43069
- const stringType = createIntrinsicType(4 /* String */, "string");
43070
- const numberType = createIntrinsicType(8 /* Number */, "number");
43071
- const bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
43072
- const falseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
43073
- const regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
43074
- const trueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
43075
- const regularTrueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
43035
+ var tupleTypes = /* @__PURE__ */ new Map();
43036
+ var unionTypes = /* @__PURE__ */ new Map();
43037
+ var intersectionTypes = /* @__PURE__ */ new Map();
43038
+ var stringLiteralTypes = /* @__PURE__ */ new Map();
43039
+ var numberLiteralTypes = /* @__PURE__ */ new Map();
43040
+ var bigIntLiteralTypes = /* @__PURE__ */ new Map();
43041
+ var enumLiteralTypes = /* @__PURE__ */ new Map();
43042
+ var indexedAccessTypes = /* @__PURE__ */ new Map();
43043
+ var templateLiteralTypes = /* @__PURE__ */ new Map();
43044
+ var stringMappingTypes = /* @__PURE__ */ new Map();
43045
+ var substitutionTypes = /* @__PURE__ */ new Map();
43046
+ var subtypeReductionCache = /* @__PURE__ */ new Map();
43047
+ var decoratorContextOverrideTypeCache = /* @__PURE__ */ new Map();
43048
+ var cachedTypes = /* @__PURE__ */ new Map();
43049
+ var evolvingArrayTypes = [];
43050
+ var undefinedProperties = /* @__PURE__ */ new Map();
43051
+ var markerTypes = /* @__PURE__ */ new Set();
43052
+ var unknownSymbol = createSymbol(4 /* Property */, "unknown");
43053
+ var resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
43054
+ var unresolvedSymbols = /* @__PURE__ */ new Map();
43055
+ var errorTypes = /* @__PURE__ */ new Map();
43056
+ var anyType = createIntrinsicType(1 /* Any */, "any");
43057
+ var autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
43058
+ var wildcardType = createIntrinsicType(1 /* Any */, "any");
43059
+ var errorType = createIntrinsicType(1 /* Any */, "error");
43060
+ var unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
43061
+ var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
43062
+ var intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
43063
+ var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
43064
+ var nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
43065
+ var undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
43066
+ var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */);
43067
+ var missingType = createIntrinsicType(32768 /* Undefined */, "undefined");
43068
+ var undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType;
43069
+ var optionalType = createIntrinsicType(32768 /* Undefined */, "undefined");
43070
+ var nullType = createIntrinsicType(65536 /* Null */, "null");
43071
+ var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */);
43072
+ var stringType = createIntrinsicType(4 /* String */, "string");
43073
+ var numberType = createIntrinsicType(8 /* Number */, "number");
43074
+ var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
43075
+ var falseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
43076
+ var regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
43077
+ var trueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
43078
+ var regularTrueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
43076
43079
  trueType.regularType = regularTrueType;
43077
43080
  trueType.freshType = trueType;
43078
43081
  regularTrueType.regularType = regularTrueType;
@@ -43081,26 +43084,26 @@ function createTypeChecker(host) {
43081
43084
  falseType.freshType = falseType;
43082
43085
  regularFalseType.regularType = regularFalseType;
43083
43086
  regularFalseType.freshType = falseType;
43084
- const booleanType = getUnionType([regularFalseType, regularTrueType]);
43085
- const esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
43086
- const voidType = createIntrinsicType(16384 /* Void */, "void");
43087
- const neverType = createIntrinsicType(131072 /* Never */, "never");
43088
- const silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
43089
- const implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
43090
- const unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
43091
- const nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
43092
- const stringOrNumberType = getUnionType([stringType, numberType]);
43093
- const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
43094
- const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
43095
- const numberOrBigIntType = getUnionType([numberType, bigintType]);
43096
- const templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
43097
- const numericStringType = getTemplateLiteralType(["", ""], [numberType]);
43098
- const restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
43099
- const permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
43100
- const uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never");
43101
- const uniqueLiteralMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t, () => "(unique literal mapper)");
43102
- let outofbandVarianceMarkerHandler;
43103
- const reportUnreliableMapper = makeFunctionTypeMapper((t) => {
43087
+ var booleanType = getUnionType([regularFalseType, regularTrueType]);
43088
+ var esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
43089
+ var voidType = createIntrinsicType(16384 /* Void */, "void");
43090
+ var neverType = createIntrinsicType(131072 /* Never */, "never");
43091
+ var silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
43092
+ var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
43093
+ var unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
43094
+ var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
43095
+ var stringOrNumberType = getUnionType([stringType, numberType]);
43096
+ var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
43097
+ var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
43098
+ var numberOrBigIntType = getUnionType([numberType, bigintType]);
43099
+ var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
43100
+ var numericStringType = getTemplateLiteralType(["", ""], [numberType]);
43101
+ var restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
43102
+ var permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
43103
+ var uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never");
43104
+ var uniqueLiteralMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t, () => "(unique literal mapper)");
43105
+ var outofbandVarianceMarkerHandler;
43106
+ var reportUnreliableMapper = makeFunctionTypeMapper((t) => {
43104
43107
  if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
43105
43108
  outofbandVarianceMarkerHandler(
43106
43109
  /*onlyUnreliable*/
@@ -43109,7 +43112,7 @@ function createTypeChecker(host) {
43109
43112
  }
43110
43113
  return t;
43111
43114
  }, () => "(unmeasurable reporter)");
43112
- const reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
43115
+ var reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
43113
43116
  if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
43114
43117
  outofbandVarianceMarkerHandler(
43115
43118
  /*onlyUnreliable*/
@@ -43118,30 +43121,30 @@ function createTypeChecker(host) {
43118
43121
  }
43119
43122
  return t;
43120
43123
  }, () => "(unreliable reporter)");
43121
- const emptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43122
- const emptyJsxObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43124
+ var emptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43125
+ var emptyJsxObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43123
43126
  emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
43124
- const emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
43127
+ var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
43125
43128
  emptyTypeLiteralSymbol.members = createSymbolTable();
43126
- const emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
43127
- const unknownEmptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43128
- const unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
43129
- const emptyGenericType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43129
+ var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
43130
+ var unknownEmptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43131
+ var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
43132
+ var emptyGenericType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43130
43133
  emptyGenericType.instantiations = /* @__PURE__ */ new Map();
43131
- const anyFunctionType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43134
+ var anyFunctionType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43132
43135
  anyFunctionType.objectFlags |= 262144 /* NonInferrableType */;
43133
- const noConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43134
- const circularConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43135
- const resolvingDefaultType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43136
- const markerSuperType = createTypeParameter();
43137
- const markerSubType = createTypeParameter();
43136
+ var noConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43137
+ var circularConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43138
+ var resolvingDefaultType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
43139
+ var markerSuperType = createTypeParameter();
43140
+ var markerSubType = createTypeParameter();
43138
43141
  markerSubType.constraint = markerSuperType;
43139
- const markerOtherType = createTypeParameter();
43140
- const markerSuperTypeForCheck = createTypeParameter();
43141
- const markerSubTypeForCheck = createTypeParameter();
43142
+ var markerOtherType = createTypeParameter();
43143
+ var markerSuperTypeForCheck = createTypeParameter();
43144
+ var markerSubTypeForCheck = createTypeParameter();
43142
43145
  markerSubTypeForCheck.constraint = markerSuperTypeForCheck;
43143
- const noTypePredicate = createTypePredicate(1 /* Identifier */, "<<unresolved>>", 0, anyType);
43144
- const anySignature = createSignature(
43146
+ var noTypePredicate = createTypePredicate(1 /* Identifier */, "<<unresolved>>", 0, anyType);
43147
+ var anySignature = createSignature(
43145
43148
  void 0,
43146
43149
  void 0,
43147
43150
  void 0,
@@ -43152,7 +43155,7 @@ function createTypeChecker(host) {
43152
43155
  0,
43153
43156
  0 /* None */
43154
43157
  );
43155
- const unknownSignature = createSignature(
43158
+ var unknownSignature = createSignature(
43156
43159
  void 0,
43157
43160
  void 0,
43158
43161
  void 0,
@@ -43163,7 +43166,7 @@ function createTypeChecker(host) {
43163
43166
  0,
43164
43167
  0 /* None */
43165
43168
  );
43166
- const resolvingSignature = createSignature(
43169
+ var resolvingSignature = createSignature(
43167
43170
  void 0,
43168
43171
  void 0,
43169
43172
  void 0,
@@ -43174,7 +43177,7 @@ function createTypeChecker(host) {
43174
43177
  0,
43175
43178
  0 /* None */
43176
43179
  );
43177
- const silentNeverSignature = createSignature(
43180
+ var silentNeverSignature = createSignature(
43178
43181
  void 0,
43179
43182
  void 0,
43180
43183
  void 0,
@@ -43185,14 +43188,14 @@ function createTypeChecker(host) {
43185
43188
  0,
43186
43189
  0 /* None */
43187
43190
  );
43188
- const enumNumberIndexInfo = createIndexInfo(
43191
+ var enumNumberIndexInfo = createIndexInfo(
43189
43192
  numberType,
43190
43193
  stringType,
43191
43194
  /*isReadonly*/
43192
43195
  true
43193
43196
  );
43194
- const iterationTypesCache = /* @__PURE__ */ new Map();
43195
- const noIterationTypes = {
43197
+ var iterationTypesCache = /* @__PURE__ */ new Map();
43198
+ var noIterationTypes = {
43196
43199
  get yieldType() {
43197
43200
  return Debug.fail("Not supported");
43198
43201
  },
@@ -43203,10 +43206,10 @@ function createTypeChecker(host) {
43203
43206
  return Debug.fail("Not supported");
43204
43207
  }
43205
43208
  };
43206
- const anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
43207
- const anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
43208
- const defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
43209
- const asyncIterationTypesResolver = {
43209
+ var anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
43210
+ var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
43211
+ var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
43212
+ var asyncIterationTypesResolver = {
43210
43213
  iterableCacheKey: "iterationTypesOfAsyncIterable",
43211
43214
  iteratorCacheKey: "iterationTypesOfAsyncIterator",
43212
43215
  iteratorSymbolName: "asyncIterator",
@@ -43219,7 +43222,7 @@ function createTypeChecker(host) {
43219
43222
  mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
43220
43223
  mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property
43221
43224
  };
43222
- const syncIterationTypesResolver = {
43225
+ var syncIterationTypesResolver = {
43223
43226
  iterableCacheKey: "iterationTypesOfIterable",
43224
43227
  iteratorCacheKey: "iterationTypesOfIterator",
43225
43228
  iteratorSymbolName: "iterator",
@@ -43232,118 +43235,118 @@ function createTypeChecker(host) {
43232
43235
  mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
43233
43236
  mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property
43234
43237
  };
43235
- let amalgamatedDuplicates;
43236
- const reverseMappedCache = /* @__PURE__ */ new Map();
43237
- let inInferTypeForHomomorphicMappedType = false;
43238
- let ambientModulesCache;
43239
- let patternAmbientModules;
43240
- let patternAmbientModuleAugmentations;
43241
- let globalObjectType;
43242
- let globalFunctionType;
43243
- let globalCallableFunctionType;
43244
- let globalNewableFunctionType;
43245
- let globalArrayType;
43246
- let globalReadonlyArrayType;
43247
- let globalStringType;
43248
- let globalNumberType;
43249
- let globalBooleanType;
43250
- let globalRegExpType;
43251
- let globalThisType;
43252
- let anyArrayType;
43253
- let autoArrayType;
43254
- let anyReadonlyArrayType;
43255
- let deferredGlobalNonNullableTypeAlias;
43256
- let deferredGlobalESSymbolConstructorSymbol;
43257
- let deferredGlobalESSymbolConstructorTypeSymbol;
43258
- let deferredGlobalESSymbolType;
43259
- let deferredGlobalTypedPropertyDescriptorType;
43260
- let deferredGlobalPromiseType;
43261
- let deferredGlobalPromiseLikeType;
43262
- let deferredGlobalPromiseConstructorSymbol;
43263
- let deferredGlobalPromiseConstructorLikeType;
43264
- let deferredGlobalIterableType;
43265
- let deferredGlobalIteratorType;
43266
- let deferredGlobalIterableIteratorType;
43267
- let deferredGlobalGeneratorType;
43268
- let deferredGlobalIteratorYieldResultType;
43269
- let deferredGlobalIteratorReturnResultType;
43270
- let deferredGlobalAsyncIterableType;
43271
- let deferredGlobalAsyncIteratorType;
43272
- let deferredGlobalAsyncIterableIteratorType;
43273
- let deferredGlobalAsyncGeneratorType;
43274
- let deferredGlobalTemplateStringsArrayType;
43275
- let deferredGlobalImportMetaType;
43276
- let deferredGlobalImportMetaExpressionType;
43277
- let deferredGlobalImportCallOptionsType;
43278
- let deferredGlobalExtractSymbol;
43279
- let deferredGlobalOmitSymbol;
43280
- let deferredGlobalAwaitedSymbol;
43281
- let deferredGlobalBigIntType;
43282
- let deferredGlobalNaNSymbol;
43283
- let deferredGlobalRecordSymbol;
43284
- let deferredGlobalClassDecoratorContextType;
43285
- let deferredGlobalClassMethodDecoratorContextType;
43286
- let deferredGlobalClassGetterDecoratorContextType;
43287
- let deferredGlobalClassSetterDecoratorContextType;
43288
- let deferredGlobalClassAccessorDecoratorContextType;
43289
- let deferredGlobalClassAccessorDecoratorTargetType;
43290
- let deferredGlobalClassAccessorDecoratorResultType;
43291
- let deferredGlobalClassFieldDecoratorContextType;
43292
- const allPotentiallyUnusedIdentifiers = /* @__PURE__ */ new Map();
43293
- let flowLoopStart = 0;
43294
- let flowLoopCount = 0;
43295
- let sharedFlowCount = 0;
43296
- let flowAnalysisDisabled = false;
43297
- let flowInvocationCount = 0;
43298
- let lastFlowNode;
43299
- let lastFlowNodeReachable;
43300
- let flowTypeCache;
43301
- const contextualTypeNodes = [];
43302
- const contextualTypes = [];
43303
- const contextualIsCache = [];
43304
- let contextualTypeCount = 0;
43305
- const inferenceContextNodes = [];
43306
- const inferenceContexts = [];
43307
- let inferenceContextCount = 0;
43308
- const emptyStringType = getStringLiteralType("");
43309
- const zeroType = getNumberLiteralType(0);
43310
- const zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
43311
- const resolutionTargets = [];
43312
- const resolutionResults = [];
43313
- const resolutionPropertyNames = [];
43314
- let suggestionCount = 0;
43315
- const maximumSuggestionCount = 10;
43316
- const mergedSymbols = [];
43317
- const symbolLinks = [];
43318
- const nodeLinks = [];
43319
- const flowLoopCaches = [];
43320
- const flowLoopNodes = [];
43321
- const flowLoopKeys = [];
43322
- const flowLoopTypes = [];
43323
- const sharedFlowNodes = [];
43324
- const sharedFlowTypes = [];
43325
- const flowNodeReachable = [];
43326
- const flowNodePostSuper = [];
43327
- const potentialThisCollisions = [];
43328
- const potentialNewTargetCollisions = [];
43329
- const potentialWeakMapSetCollisions = [];
43330
- const potentialReflectCollisions = [];
43331
- const potentialUnusedRenamedBindingElementsInTypes = [];
43332
- const awaitedTypeStack = [];
43333
- const diagnostics = createDiagnosticCollection();
43334
- const suggestionDiagnostics = createDiagnosticCollection();
43335
- const typeofType = createTypeofType();
43336
- let _jsxNamespace;
43337
- let _jsxFactoryEntity;
43338
- const subtypeRelation = /* @__PURE__ */ new Map();
43339
- const strictSubtypeRelation = /* @__PURE__ */ new Map();
43340
- const assignableRelation = /* @__PURE__ */ new Map();
43341
- const comparableRelation = /* @__PURE__ */ new Map();
43342
- const identityRelation = /* @__PURE__ */ new Map();
43343
- const enumRelation = /* @__PURE__ */ new Map();
43344
- const builtinGlobals = createSymbolTable();
43238
+ var amalgamatedDuplicates;
43239
+ var reverseMappedCache = /* @__PURE__ */ new Map();
43240
+ var inInferTypeForHomomorphicMappedType = false;
43241
+ var ambientModulesCache;
43242
+ var patternAmbientModules;
43243
+ var patternAmbientModuleAugmentations;
43244
+ var globalObjectType;
43245
+ var globalFunctionType;
43246
+ var globalCallableFunctionType;
43247
+ var globalNewableFunctionType;
43248
+ var globalArrayType;
43249
+ var globalReadonlyArrayType;
43250
+ var globalStringType;
43251
+ var globalNumberType;
43252
+ var globalBooleanType;
43253
+ var globalRegExpType;
43254
+ var globalThisType;
43255
+ var anyArrayType;
43256
+ var autoArrayType;
43257
+ var anyReadonlyArrayType;
43258
+ var deferredGlobalNonNullableTypeAlias;
43259
+ var deferredGlobalESSymbolConstructorSymbol;
43260
+ var deferredGlobalESSymbolConstructorTypeSymbol;
43261
+ var deferredGlobalESSymbolType;
43262
+ var deferredGlobalTypedPropertyDescriptorType;
43263
+ var deferredGlobalPromiseType;
43264
+ var deferredGlobalPromiseLikeType;
43265
+ var deferredGlobalPromiseConstructorSymbol;
43266
+ var deferredGlobalPromiseConstructorLikeType;
43267
+ var deferredGlobalIterableType;
43268
+ var deferredGlobalIteratorType;
43269
+ var deferredGlobalIterableIteratorType;
43270
+ var deferredGlobalGeneratorType;
43271
+ var deferredGlobalIteratorYieldResultType;
43272
+ var deferredGlobalIteratorReturnResultType;
43273
+ var deferredGlobalAsyncIterableType;
43274
+ var deferredGlobalAsyncIteratorType;
43275
+ var deferredGlobalAsyncIterableIteratorType;
43276
+ var deferredGlobalAsyncGeneratorType;
43277
+ var deferredGlobalTemplateStringsArrayType;
43278
+ var deferredGlobalImportMetaType;
43279
+ var deferredGlobalImportMetaExpressionType;
43280
+ var deferredGlobalImportCallOptionsType;
43281
+ var deferredGlobalExtractSymbol;
43282
+ var deferredGlobalOmitSymbol;
43283
+ var deferredGlobalAwaitedSymbol;
43284
+ var deferredGlobalBigIntType;
43285
+ var deferredGlobalNaNSymbol;
43286
+ var deferredGlobalRecordSymbol;
43287
+ var deferredGlobalClassDecoratorContextType;
43288
+ var deferredGlobalClassMethodDecoratorContextType;
43289
+ var deferredGlobalClassGetterDecoratorContextType;
43290
+ var deferredGlobalClassSetterDecoratorContextType;
43291
+ var deferredGlobalClassAccessorDecoratorContextType;
43292
+ var deferredGlobalClassAccessorDecoratorTargetType;
43293
+ var deferredGlobalClassAccessorDecoratorResultType;
43294
+ var deferredGlobalClassFieldDecoratorContextType;
43295
+ var allPotentiallyUnusedIdentifiers = /* @__PURE__ */ new Map();
43296
+ var flowLoopStart = 0;
43297
+ var flowLoopCount = 0;
43298
+ var sharedFlowCount = 0;
43299
+ var flowAnalysisDisabled = false;
43300
+ var flowInvocationCount = 0;
43301
+ var lastFlowNode;
43302
+ var lastFlowNodeReachable;
43303
+ var flowTypeCache;
43304
+ var contextualTypeNodes = [];
43305
+ var contextualTypes = [];
43306
+ var contextualIsCache = [];
43307
+ var contextualTypeCount = 0;
43308
+ var inferenceContextNodes = [];
43309
+ var inferenceContexts = [];
43310
+ var inferenceContextCount = 0;
43311
+ var emptyStringType = getStringLiteralType("");
43312
+ var zeroType = getNumberLiteralType(0);
43313
+ var zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
43314
+ var resolutionTargets = [];
43315
+ var resolutionResults = [];
43316
+ var resolutionPropertyNames = [];
43317
+ var suggestionCount = 0;
43318
+ var maximumSuggestionCount = 10;
43319
+ var mergedSymbols = [];
43320
+ var symbolLinks = [];
43321
+ var nodeLinks = [];
43322
+ var flowLoopCaches = [];
43323
+ var flowLoopNodes = [];
43324
+ var flowLoopKeys = [];
43325
+ var flowLoopTypes = [];
43326
+ var sharedFlowNodes = [];
43327
+ var sharedFlowTypes = [];
43328
+ var flowNodeReachable = [];
43329
+ var flowNodePostSuper = [];
43330
+ var potentialThisCollisions = [];
43331
+ var potentialNewTargetCollisions = [];
43332
+ var potentialWeakMapSetCollisions = [];
43333
+ var potentialReflectCollisions = [];
43334
+ var potentialUnusedRenamedBindingElementsInTypes = [];
43335
+ var awaitedTypeStack = [];
43336
+ var diagnostics = createDiagnosticCollection();
43337
+ var suggestionDiagnostics = createDiagnosticCollection();
43338
+ var typeofType = createTypeofType();
43339
+ var _jsxNamespace;
43340
+ var _jsxFactoryEntity;
43341
+ var subtypeRelation = /* @__PURE__ */ new Map();
43342
+ var strictSubtypeRelation = /* @__PURE__ */ new Map();
43343
+ var assignableRelation = /* @__PURE__ */ new Map();
43344
+ var comparableRelation = /* @__PURE__ */ new Map();
43345
+ var identityRelation = /* @__PURE__ */ new Map();
43346
+ var enumRelation = /* @__PURE__ */ new Map();
43347
+ var builtinGlobals = createSymbolTable();
43345
43348
  builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
43346
- const suggestedExtensions = [
43349
+ var suggestedExtensions = [
43347
43350
  [".mts", ".mjs"],
43348
43351
  [".ts", ".js"],
43349
43352
  [".cts", ".cjs"],
@@ -53540,20 +53543,6 @@ function createTypeChecker(host) {
53540
53543
  return t.flags & 1048576 /* Union */ && baseTypes.length === types.length ? getUnionType(baseTypes) : t.flags & 2097152 /* Intersection */ && baseTypes.length ? getIntersectionType(baseTypes) : void 0;
53541
53544
  }
53542
53545
  if (t.flags & 4194304 /* Index */) {
53543
- if (t.type.flags & 8388608 /* IndexedAccess */) {
53544
- const indexedAccess = t.type;
53545
- if (!isGenericObjectType(indexedAccess.objectType)) {
53546
- const baseIndexType = getBaseConstraint(indexedAccess.indexType);
53547
- const indexedAccessType = baseIndexType && getIndexedAccessTypeOrUndefined(indexedAccess.objectType, baseIndexType);
53548
- const mappedIndexTypeOfIndexedAccess = indexedAccessType && mapType(indexedAccessType, getIndexType);
53549
- const narrowed = mappedIndexTypeOfIndexedAccess && filterType(keyofConstraintType, (t2) => {
53550
- return !(getIntersectionType([t2, mappedIndexTypeOfIndexedAccess]).flags & 131072 /* Never */);
53551
- });
53552
- if (narrowed) {
53553
- return narrowed;
53554
- }
53555
- }
53556
- }
53557
53546
  return keyofConstraintType;
53558
53547
  }
53559
53548
  if (t.flags & 134217728 /* TemplateLiteral */) {
@@ -54522,7 +54511,7 @@ function createTypeChecker(host) {
54522
54511
  const [childTypeParameter = declaration.parent, grandParent] = walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent);
54523
54512
  if (grandParent.kind === 180 /* TypeReference */ && !omitTypeReferences) {
54524
54513
  const typeReference = grandParent;
54525
- const typeParameters = getTypeParametersForTypeReference(typeReference);
54514
+ const typeParameters = getTypeParametersForTypeReferenceOrImport(typeReference);
54526
54515
  if (typeParameters) {
54527
54516
  const index = typeReference.typeArguments.indexOf(childTypeParameter);
54528
54517
  if (index < typeParameters.length) {
@@ -57185,13 +57174,6 @@ function createTypeChecker(host) {
57185
57174
  if (meaning === 111551 /* Value */) {
57186
57175
  return getInstantiationExpressionType(getTypeOfSymbol(symbol), node);
57187
57176
  } else {
57188
- const type = tryGetDeclaredTypeOfSymbol(resolvedSymbol);
57189
- const typeParameters = type && getTypeParametersForTypeAndSymbol(type, resolvedSymbol);
57190
- if (node.typeArguments && typeParameters) {
57191
- addLazyDiagnostic(() => {
57192
- checkTypeArgumentConstraints(node, typeParameters);
57193
- });
57194
- }
57195
57177
  return getTypeReferenceType(node, resolvedSymbol);
57196
57178
  }
57197
57179
  }
@@ -73908,7 +73890,7 @@ function createTypeChecker(host) {
73908
73890
  error(node.name, Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
73909
73891
  }
73910
73892
  }
73911
- if ((node.questionToken || isJSDocOptionalParameter(node)) && isBindingPattern(node.name) && func.body) {
73893
+ if (!node.initializer && isOptionalDeclaration(node) && isBindingPattern(node.name) && func.body) {
73912
73894
  error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
73913
73895
  }
73914
73896
  if (node.name && isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
@@ -74430,8 +74412,8 @@ function createTypeChecker(host) {
74430
74412
  }
74431
74413
  return void 0;
74432
74414
  }
74433
- function getTypeParametersForTypeReference(node) {
74434
- const type = getTypeFromTypeReference(node);
74415
+ function getTypeParametersForTypeReferenceOrImport(node) {
74416
+ const type = getTypeFromTypeNode(node);
74435
74417
  if (!isErrorType(type)) {
74436
74418
  const symbol = getNodeLinks(node).resolvedSymbol;
74437
74419
  if (symbol) {
@@ -74449,11 +74431,14 @@ function createTypeChecker(host) {
74449
74431
  }
74450
74432
  }
74451
74433
  forEach(node.typeArguments, checkSourceElement);
74452
- const type = getTypeFromTypeReference(node);
74434
+ checkTypeReferenceOrImport(node);
74435
+ }
74436
+ function checkTypeReferenceOrImport(node) {
74437
+ const type = getTypeFromTypeNode(node);
74453
74438
  if (!isErrorType(type)) {
74454
74439
  if (node.typeArguments) {
74455
74440
  addLazyDiagnostic(() => {
74456
- const typeParameters = getTypeParametersForTypeReference(node);
74441
+ const typeParameters = getTypeParametersForTypeReferenceOrImport(node);
74457
74442
  if (typeParameters) {
74458
74443
  checkTypeArgumentConstraints(node, typeParameters);
74459
74444
  }
@@ -74475,7 +74460,7 @@ function createTypeChecker(host) {
74475
74460
  const typeReferenceNode = tryCast(node.parent, isTypeReferenceType);
74476
74461
  if (!typeReferenceNode)
74477
74462
  return void 0;
74478
- const typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
74463
+ const typeParameters = getTypeParametersForTypeReferenceOrImport(typeReferenceNode);
74479
74464
  if (!typeParameters)
74480
74465
  return void 0;
74481
74466
  const constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
@@ -74655,7 +74640,7 @@ function createTypeChecker(host) {
74655
74640
  }
74656
74641
  }
74657
74642
  }
74658
- getTypeFromTypeNode(node);
74643
+ checkTypeReferenceOrImport(node);
74659
74644
  }
74660
74645
  function checkNamedTupleMember(node) {
74661
74646
  if (node.dotDotDotToken && node.questionToken) {
@@ -84094,31 +84079,31 @@ function extractSingleNode(nodes) {
84094
84079
 
84095
84080
  // src/compiler/sourcemap.ts
84096
84081
  function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) {
84097
- const { enter, exit } = generatorOptions.extendedDiagnostics ? createTimer("Source Map", "beforeSourcemap", "afterSourcemap") : nullTimer;
84098
- const rawSources = [];
84099
- const sources = [];
84100
- const sourceToSourceIndexMap = /* @__PURE__ */ new Map();
84101
- let sourcesContent;
84102
- const names = [];
84103
- let nameToNameIndexMap;
84104
- const mappingCharCodes = [];
84105
- let mappings = "";
84106
- let lastGeneratedLine = 0;
84107
- let lastGeneratedCharacter = 0;
84108
- let lastSourceIndex = 0;
84109
- let lastSourceLine = 0;
84110
- let lastSourceCharacter = 0;
84111
- let lastNameIndex = 0;
84112
- let hasLast = false;
84113
- let pendingGeneratedLine = 0;
84114
- let pendingGeneratedCharacter = 0;
84115
- let pendingSourceIndex = 0;
84116
- let pendingSourceLine = 0;
84117
- let pendingSourceCharacter = 0;
84118
- let pendingNameIndex = 0;
84119
- let hasPending = false;
84120
- let hasPendingSource = false;
84121
- let hasPendingName = false;
84082
+ var { enter, exit } = generatorOptions.extendedDiagnostics ? createTimer("Source Map", "beforeSourcemap", "afterSourcemap") : nullTimer;
84083
+ var rawSources = [];
84084
+ var sources = [];
84085
+ var sourceToSourceIndexMap = /* @__PURE__ */ new Map();
84086
+ var sourcesContent;
84087
+ var names = [];
84088
+ var nameToNameIndexMap;
84089
+ var mappingCharCodes = [];
84090
+ var mappings = "";
84091
+ var lastGeneratedLine = 0;
84092
+ var lastGeneratedCharacter = 0;
84093
+ var lastSourceIndex = 0;
84094
+ var lastSourceLine = 0;
84095
+ var lastSourceCharacter = 0;
84096
+ var lastNameIndex = 0;
84097
+ var hasLast = false;
84098
+ var pendingGeneratedLine = 0;
84099
+ var pendingGeneratedCharacter = 0;
84100
+ var pendingSourceIndex = 0;
84101
+ var pendingSourceLine = 0;
84102
+ var pendingSourceCharacter = 0;
84103
+ var pendingNameIndex = 0;
84104
+ var hasPending = false;
84105
+ var hasPendingSource = false;
84106
+ var hasPendingName = false;
84122
84107
  return {
84123
84108
  getSources: () => rawSources,
84124
84109
  addSource,
@@ -93073,7 +93058,7 @@ function transformES2018(context) {
93073
93058
  );
93074
93059
  }
93075
93060
  function visitBinaryExpression(node, expressionResultIsUnused2) {
93076
- if (isDestructuringAssignment(node) && node.left.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
93061
+ if (isDestructuringAssignment(node) && containsObjectRestOrSpread(node.left)) {
93077
93062
  return flattenDestructuringAssignment(
93078
93063
  node,
93079
93064
  visitor,
@@ -93205,7 +93190,7 @@ function transformES2018(context) {
93205
93190
  }
93206
93191
  function visitForOfStatement(node, outermostLabeledStatement) {
93207
93192
  const ancestorFacts = enterSubtree(0 /* IterationStatementExcludes */, 2 /* IterationStatementIncludes */);
93208
- if (node.initializer.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
93193
+ if (node.initializer.transformFlags & 65536 /* ContainsObjectRestOrSpread */ || isAssignmentPattern(node.initializer) && containsObjectRestOrSpread(node.initializer)) {
93209
93194
  node = transformForOfStatementWithObjectRest(node);
93210
93195
  }
93211
93196
  const result = node.awaitModifier ? transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) : factory2.restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement);
@@ -106442,15 +106427,15 @@ function getFirstProjectOutput(configFile, ignoreCase) {
106442
106427
  return Debug.fail(`project ${configFile.options.configFilePath} expected to have at least one output`);
106443
106428
  }
106444
106429
  function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, declarationTransformers }, emitOnly, onlyBuildInfo, forceDtsEmit) {
106445
- const compilerOptions = host.getCompilerOptions();
106446
- const sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
106447
- const emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
106448
- const emitterDiagnostics = createDiagnosticCollection();
106449
- const newLine = getNewLineCharacter(compilerOptions);
106450
- const writer = createTextWriter(newLine);
106451
- const { enter, exit } = createTimer("printTime", "beforePrint", "afterPrint");
106452
- let bundleBuildInfo;
106453
- let emitSkipped = false;
106430
+ var compilerOptions = host.getCompilerOptions();
106431
+ var sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
106432
+ var emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
106433
+ var emitterDiagnostics = createDiagnosticCollection();
106434
+ var newLine = getNewLineCharacter(compilerOptions);
106435
+ var writer = createTextWriter(newLine);
106436
+ var { enter, exit } = createTimer("printTime", "beforePrint", "afterPrint");
106437
+ var bundleBuildInfo;
106438
+ var emitSkipped = false;
106454
106439
  enter();
106455
106440
  forEachEmittedFile(
106456
106441
  host,
@@ -107017,7 +107002,7 @@ var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinte
107017
107002
  var createPrinterWithRemoveCommentsNeverAsciiEscape = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, neverAsciiEscape: true }));
107018
107003
  var createPrinterWithRemoveCommentsOmitTrailingSemicolon = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, omitTrailingSemicolon: true }));
107019
107004
  function createPrinter(printerOptions = {}, handlers = {}) {
107020
- const {
107005
+ var {
107021
107006
  hasGlobalName,
107022
107007
  onEmitNode = noEmitNotification,
107023
107008
  isEmitNotificationEnabled,
@@ -107029,57 +107014,57 @@ function createPrinter(printerOptions = {}, handlers = {}) {
107029
107014
  onBeforeEmitToken,
107030
107015
  onAfterEmitToken
107031
107016
  } = handlers;
107032
- const extendedDiagnostics = !!printerOptions.extendedDiagnostics;
107033
- const newLine = getNewLineCharacter(printerOptions);
107034
- const moduleKind = getEmitModuleKind(printerOptions);
107035
- const bundledHelpers = /* @__PURE__ */ new Map();
107036
- let currentSourceFile;
107037
- let nodeIdToGeneratedName;
107038
- let nodeIdToGeneratedPrivateName;
107039
- let autoGeneratedIdToGeneratedName;
107040
- let generatedNames;
107041
- let formattedNameTempFlagsStack;
107042
- let formattedNameTempFlags;
107043
- let privateNameTempFlagsStack;
107044
- let privateNameTempFlags;
107045
- let tempFlagsStack;
107046
- let tempFlags;
107047
- let reservedNamesStack;
107048
- let reservedNames;
107049
- let reservedPrivateNamesStack;
107050
- let reservedPrivateNames;
107051
- let preserveSourceNewlines = printerOptions.preserveSourceNewlines;
107052
- let nextListElementPos;
107053
- let writer;
107054
- let ownWriter;
107055
- let write = writeBase;
107056
- let isOwnFileEmit;
107057
- const bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : void 0;
107058
- const relativeToBuildInfo = bundleFileInfo ? Debug.checkDefined(printerOptions.relativeToBuildInfo) : void 0;
107059
- const recordInternalSection = printerOptions.recordInternalSection;
107060
- let sourceFileTextPos = 0;
107061
- let sourceFileTextKind = "text" /* Text */;
107062
- let sourceMapsDisabled = true;
107063
- let sourceMapGenerator;
107064
- let sourceMapSource;
107065
- let sourceMapSourceIndex = -1;
107066
- let mostRecentlyAddedSourceMapSource;
107067
- let mostRecentlyAddedSourceMapSourceIndex = -1;
107068
- let containerPos = -1;
107069
- let containerEnd = -1;
107070
- let declarationListContainerEnd = -1;
107071
- let currentLineMap;
107072
- let detachedCommentsInfo;
107073
- let hasWrittenComment = false;
107074
- let commentsDisabled = !!printerOptions.removeComments;
107075
- let lastSubstitution;
107076
- let currentParenthesizerRule;
107077
- const { enter: enterComment, exit: exitComment } = createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
107078
- const parenthesizer = factory.parenthesizer;
107079
- const typeArgumentParenthesizerRuleSelector = {
107017
+ var extendedDiagnostics = !!printerOptions.extendedDiagnostics;
107018
+ var newLine = getNewLineCharacter(printerOptions);
107019
+ var moduleKind = getEmitModuleKind(printerOptions);
107020
+ var bundledHelpers = /* @__PURE__ */ new Map();
107021
+ var currentSourceFile;
107022
+ var nodeIdToGeneratedName;
107023
+ var nodeIdToGeneratedPrivateName;
107024
+ var autoGeneratedIdToGeneratedName;
107025
+ var generatedNames;
107026
+ var formattedNameTempFlagsStack;
107027
+ var formattedNameTempFlags;
107028
+ var privateNameTempFlagsStack;
107029
+ var privateNameTempFlags;
107030
+ var tempFlagsStack;
107031
+ var tempFlags;
107032
+ var reservedNamesStack;
107033
+ var reservedNames;
107034
+ var reservedPrivateNamesStack;
107035
+ var reservedPrivateNames;
107036
+ var preserveSourceNewlines = printerOptions.preserveSourceNewlines;
107037
+ var nextListElementPos;
107038
+ var writer;
107039
+ var ownWriter;
107040
+ var write = writeBase;
107041
+ var isOwnFileEmit;
107042
+ var bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : void 0;
107043
+ var relativeToBuildInfo = bundleFileInfo ? Debug.checkDefined(printerOptions.relativeToBuildInfo) : void 0;
107044
+ var recordInternalSection = printerOptions.recordInternalSection;
107045
+ var sourceFileTextPos = 0;
107046
+ var sourceFileTextKind = "text" /* Text */;
107047
+ var sourceMapsDisabled = true;
107048
+ var sourceMapGenerator;
107049
+ var sourceMapSource;
107050
+ var sourceMapSourceIndex = -1;
107051
+ var mostRecentlyAddedSourceMapSource;
107052
+ var mostRecentlyAddedSourceMapSourceIndex = -1;
107053
+ var containerPos = -1;
107054
+ var containerEnd = -1;
107055
+ var declarationListContainerEnd = -1;
107056
+ var currentLineMap;
107057
+ var detachedCommentsInfo;
107058
+ var hasWrittenComment = false;
107059
+ var commentsDisabled = !!printerOptions.removeComments;
107060
+ var lastSubstitution;
107061
+ var currentParenthesizerRule;
107062
+ var { enter: enterComment, exit: exitComment } = createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
107063
+ var parenthesizer = factory.parenthesizer;
107064
+ var typeArgumentParenthesizerRuleSelector = {
107080
107065
  select: (index) => index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : void 0
107081
107066
  };
107082
- const emitBinaryExpression = createEmitBinaryExpression();
107067
+ var emitBinaryExpression = createEmitBinaryExpression();
107083
107068
  reset();
107084
107069
  return {
107085
107070
  // public API
@@ -115442,7 +115427,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
115442
115427
  if (version2 === "6.0" /* v6_0 */) {
115443
115428
  createDiagnostic(Diagnostics.Flag_0_is_deprecated_Please_remove_it_from_your_configuration, value || name);
115444
115429
  } else {
115445
- 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 */);
115430
+ 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 */);
115446
115431
  }
115447
115432
  }
115448
115433
  function createDiagnosticExplainingFile(file, fileProcessingReason, diagnostic, args) {