@typescript-deploys/pr-build 5.0.0-pr-52921-12 → 5.0.0-pr-52944-9

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230222`;
+var version = `${versionMajorMinor}.0-insiders.20230223`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -7992,7 +7992,6 @@ var unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 18
 var unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2208, 2228, 2230, 2237, 2259, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3328, 3331, 3333, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6e3, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7673, 7675, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43047, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69376, 69404, 69415, 69415, 69424, 69456, 69600, 69622, 69632, 69702, 69734, 69743, 69759, 69818, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69958, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70096, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70206, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70751, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71680, 71738, 71840, 71913, 71935, 71935, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123584, 123641, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999];
 var commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore)/;
 var commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/;
-var semanticJSDocTagRegEx = /@(?:see|link)/i;
 function lookupInUnicodeMap(code, map2) {
   if (code < map2[0]) {
     return false;
@@ -8478,7 +8477,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   var tokenFlags;
   var commentDirectives;
   var inJSDocType = 0;
-  var skipJSDoc = false;
   setText(text, start, length2);
   var scanner = {
     getStartPos: () => startPos,
@@ -8523,8 +8521,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     setInJSDocType,
     tryScan,
     lookAhead,
-    scanRange,
-    setSkipJSDoc
+    scanRange
   };
   if (Debug.isDebugging) {
     Object.defineProperty(scanner, "__debugShowCurrentPositionInText", {
@@ -9228,7 +9225,9 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           }
           if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
             pos += 2;
-            const isJSDoc2 = text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) !== 47 /* slash */;
+            if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) !== 47 /* slash */) {
+              tokenFlags |= 2 /* PrecedingJSDocComment */;
+            }
             let commentClosed = false;
             let lastLineStart = tokenPos;
             while (pos < end) {
@@ -9244,9 +9243,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 tokenFlags |= 1 /* PrecedingLineBreak */;
               }
             }
-            if (isJSDoc2 && (!skipJSDoc || semanticJSDocTagRegEx.test(text.slice(tokenPos, pos)))) {
-              tokenFlags |= 2 /* PrecedingJSDocComment */;
-            }
             commentDirectives = appendIfCommentDirective(commentDirectives, text.slice(lastLineStart, pos), commentDirectiveRegExMultiLine, lastLineStart);
             if (!commentClosed) {
               error(Diagnostics.Asterisk_Slash_expected);
@@ -9914,9 +9910,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   function setLanguageVariant(variant) {
     languageVariant = variant;
   }
-  function setSkipJSDoc(skip) {
-    skipJSDoc = skip;
-  }
   function setTextPos(textPos) {
     Debug.assert(textPos >= 0);
     pos = textPos;
@@ -19843,24 +19836,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function propagateAssignmentPatternFlags(node) {
-    if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
-      return 65536 /* ContainsObjectRestOrSpread */;
-    if (node.transformFlags & 128 /* ContainsES2018 */) {
-      for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
-        const target = getTargetOfBindingOrAssignmentElement(element);
-        if (target && isAssignmentPattern(target)) {
-          if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
-            return 65536 /* ContainsObjectRestOrSpread */;
-          }
-          if (target.transformFlags & 128 /* ContainsES2018 */) {
-            const flags2 = propagateAssignmentPatternFlags(target);
-            if (flags2)
-              return flags2;
-          }
-        }
-      }
-    }
-    return 0 /* None */;
+    return containsObjectRestOrSpread(node) ? 65536 /* ContainsObjectRestOrSpread */ : 0 /* None */;
   }
   function updateBinaryExpression(node, left, operator, right) {
     return node.left !== left || node.operatorToken !== operator || node.right !== right ? update(createBinaryExpression(left, operator, right), node) : node;
@@ -25357,6 +25333,25 @@ function flattenCommaList(node) {
   flattenCommaListWorker(node, expressions);
   return expressions;
 }
+function containsObjectRestOrSpread(node) {
+  if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
+    return true;
+  if (node.transformFlags & 128 /* ContainsES2018 */) {
+    for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
+      const target = getTargetOfBindingOrAssignmentElement(element);
+      if (target && isAssignmentPattern(target)) {
+        if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
+          return true;
+        }
+        if (target.transformFlags & 128 /* ContainsES2018 */) {
+          if (containsObjectRestOrSpread(target))
+            return true;
+        }
+      }
+    }
+  }
+  return false;
+}
 
 // src/compiler/factory/utilitiesPublic.ts
 function setTextRange(range, location) {
@@ -25966,8 +25961,7 @@ function createSourceFile(fileName, sourceText, languageVersionOrOptions, setPar
   const {
     languageVersion,
     setExternalModuleIndicator: overrideSetExternalModuleIndicator,
-    impliedNodeFormat: format,
-    skipJSDoc
+    impliedNodeFormat: format
   } = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : { languageVersion: languageVersionOrOptions };
   if (languageVersion === 100 /* JSON */) {
     result = Parser.parseSourceFile(
@@ -25978,8 +25972,7 @@ function createSourceFile(fileName, sourceText, languageVersionOrOptions, setPar
       void 0,
       setParentNodes,
       6 /* JSON */,
-      noop,
-      skipJSDoc
+      noop
     );
   } else {
     const setIndicator = format === void 0 ? overrideSetExternalModuleIndicator : (file) => {
@@ -25994,8 +25987,7 @@ function createSourceFile(fileName, sourceText, languageVersionOrOptions, setPar
       void 0,
       setParentNodes,
       scriptKind,
-      setIndicator,
-      skipJSDoc
+      setIndicator
     );
   }
   perfLogger.logStopParseSourceFile();
@@ -26086,7 +26078,7 @@ var Parser;
   var contextFlags;
   var topLevel = true;
   var parseErrorBeforeNextFinishedNode = false;
-  function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride, skipJSDoc = false) {
+  function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride) {
     var _a2;
     scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
     if (scriptKind2 === 6 /* JSON */) {
@@ -26110,7 +26102,7 @@ var Parser;
       result2.pragmas = emptyMap;
       return result2;
     }
-    initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, scriptKind2, skipJSDoc);
+    initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, scriptKind2);
     const result = parseSourceFileWorker(languageVersion2, setParentNodes, scriptKind2, setExternalModuleIndicatorOverride || setExternalModuleIndicator);
     clearState();
     return result;
@@ -26123,9 +26115,7 @@ var Parser;
       languageVersion2,
       /*syntaxCursor*/
       void 0,
-      1 /* JS */,
-      /*skipJSDoc*/
-      false
+      1 /* JS */
     );
     nextToken();
     const entityName = parseEntityName(
@@ -26138,15 +26128,7 @@ var Parser;
   }
   Parser2.parseIsolatedEntityName = parseIsolatedEntityName2;
   function parseJsonText2(fileName2, sourceText2, languageVersion2 = 2 /* ES2015 */, syntaxCursor2, setParentNodes = false) {
-    initializeState(
-      fileName2,
-      sourceText2,
-      languageVersion2,
-      syntaxCursor2,
-      6 /* JSON */,
-      /*skipJSDoc*/
-      false
-    );
+    initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, 6 /* JSON */);
     sourceFlags = contextFlags;
     nextToken();
     const pos = getNodePos();
@@ -26227,7 +26209,7 @@ var Parser;
     return result;
   }
   Parser2.parseJsonText = parseJsonText2;
-  function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind, _skipJSDoc) {
+  function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind) {
     NodeConstructor2 = objectAllocator.getNodeConstructor();
     TokenConstructor2 = objectAllocator.getTokenConstructor();
     IdentifierConstructor2 = objectAllocator.getIdentifierConstructor();
@@ -26263,13 +26245,11 @@ var Parser;
     scanner.setOnError(scanError);
     scanner.setScriptTarget(languageVersion);
     scanner.setLanguageVariant(languageVariant);
-    scanner.setSkipJSDoc(_skipJSDoc && !(contextFlags & 262144 /* JavaScriptFile */));
   }
   function clearState() {
     scanner.clearCommentDirectives();
     scanner.setText("");
     scanner.setOnError(void 0);
-    scanner.setSkipJSDoc(false);
     sourceText = void 0;
     languageVersion = void 0;
     syntaxCursor = void 0;
@@ -26292,8 +26272,7 @@ var Parser;
     nextToken();
     const statements = parseList(0 /* SourceElements */, parseStatement);
     Debug.assert(token() === 1 /* EndOfFileToken */);
-    const endHasJSDoc = hasPrecedingJSDocComment();
-    const endOfFileToken = withJSDoc(parseTokenNode(), endHasJSDoc);
+    const endOfFileToken = addJSDocComment(parseTokenNode());
     const sourceFile = createSourceFile2(fileName, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator2);
     processCommentPragmas(sourceFile, sourceText);
     processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
@@ -28896,7 +28875,7 @@ var Parser;
       equalsGreaterThanToken,
       body
     );
-    return finishNode(node, pos);
+    return addJSDocComment(finishNode(node, pos));
   }
   function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
     const triState = isParenthesizedArrowFunctionExpression();
@@ -31578,9 +31557,7 @@ var Parser;
         99 /* Latest */,
         /*_syntaxCursor:*/
         void 0,
-        1 /* JS */,
-        /*skipJSDoc*/
-        false
+        1 /* JS */
       );
       scanner.setText(content, start, length2);
       currentToken = scanner.scan();
@@ -31644,9 +31621,7 @@ var Parser;
         99 /* Latest */,
         /*_syntaxCursor:*/
         void 0,
-        1 /* JS */,
-        /*skipJSDoc*/
-        false
+        1 /* JS */
       );
       const jsDoc = doInsideOfContext(8388608 /* JSDoc */, () => parseJSDocCommentWorker(start, length2));
       const sourceFile = { languageVariant: 0 /* Standard */, text: content };
@@ -33491,12 +33466,6 @@ var commonOptionsWithBuild = [
     isCommandLineOnly: true,
     description: Diagnostics.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit,
     defaultValueDescription: Diagnostics.Platform_specific
-  },
-  {
-    name: "skipJSDocParsing",
-    type: "boolean",
-    defaultValueDescription: false,
-    hiddenInAllViews: true
   }
 ];
 var targetOptionDeclaration = {
@@ -54452,27 +54421,15 @@ function createTypeChecker(host) {
       isInJSFile(signature.declaration)
     );
   }
-  function getBaseSignature(signature) {
-    const typeParameters = signature.typeParameters;
-    if (typeParameters) {
-      if (signature.baseSignatureCache) {
-        return signature.baseSignatureCache;
-      }
-      const typeEraser = createTypeEraser(typeParameters);
-      const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
-      let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
-      for (let i = 0; i < typeParameters.length - 1; i++) {
-        baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
-      }
-      baseConstraints = instantiateTypes(baseConstraints, typeEraser);
-      return signature.baseSignatureCache = instantiateSignature(
-        signature,
-        createTypeMapper(typeParameters, baseConstraints),
-        /*eraseTypeParameters*/
-        true
-      );
+  function getTypeParameterConstraintMapper(typeParameters) {
+    const typeEraser = createTypeEraser(typeParameters);
+    const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
+    let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
+    for (let i = 0; i < typeParameters.length - 1; i++) {
+      baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
     }
-    return signature;
+    baseConstraints = instantiateTypes(baseConstraints, typeEraser);
+    return createTypeMapper(typeParameters, baseConstraints);
   }
   function getOrCreateTypeFromSignature(signature) {
     var _a2;
@@ -56997,9 +56954,9 @@ function createTypeChecker(host) {
           }
         }
         if (!checkTypeDeferred) {
-          inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+          inferTypes(context, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
         }
-        const innerMapper = combineTypeMappers(freshMapper, context.mapper);
+        const innerMapper = combineTypeMappers(freshMapper, getMapperFromContext(context));
         combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
@@ -57686,8 +57643,11 @@ function createTypeChecker(host) {
       void 0
     );
   }
-  function createBackreferenceMapper(context, index) {
-    const forwardInferences = context.inferences.slice(index);
+  function createBackreferenceMapper(context, inference) {
+    const inferences = context.inferences.indexOf(inference) >= 0 ? context.inferences : context.freeTypeVariables;
+    Debug.assert(inferences, "Inference for backreference mapper must exist within provided context");
+    const index = inferences.indexOf(inference);
+    const forwardInferences = inferences.slice(index);
     return createTypeMapper(map(forwardInferences, (i) => i.typeParameter), map(forwardInferences, () => unknownType));
   }
   function combineTypeMappers(mapper1, mapper2) {
@@ -60501,9 +60461,10 @@ function createTypeChecker(host) {
               0 /* None */,
               isRelatedToWorker
             );
-            inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
-            sourceExtends = instantiateType(sourceExtends, ctx.mapper);
-            mapper = ctx.mapper;
+            inferTypes(ctx, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+            const newMapper = getMapperFromContext(ctx);
+            sourceExtends = instantiateType(sourceExtends, newMapper);
+            mapper = newMapper;
           }
           if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, 3 /* Both */))) {
             if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), 3 /* Both */, reportErrors2)) {
@@ -62341,7 +62302,12 @@ function createTypeChecker(host) {
     return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
   }
   function cloneInferenceContext(context, extraFlags = 0) {
-    return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
+    const newContext = context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
+    if (context && context.freeTypeVariables) {
+      newContext.freeTypeVariables = map(context.freeTypeVariables, cloneInferenceInfo);
+      newContext.freeTypeVariableSourceSignatures = new Map(mapIterator(context.freeTypeVariableSourceSignatures.entries(), ([k, v]) => [k, new Map(v.entries())]));
+    }
+    return newContext;
   }
   function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
     const context = {
@@ -62358,20 +62324,29 @@ function createTypeChecker(host) {
     return context;
   }
   function makeFixingMapperForContext(context) {
-    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference, i) => () => {
+    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference) => () => {
       if (!inference.isFixed) {
         inferFromIntraExpressionSites(context);
         clearCachedInferences(context.inferences);
         inference.isFixed = true;
       }
-      return getInferredType(context, i);
+      return getInferredType(context, inference);
     }));
   }
   function makeNonFixingMapperForContext(context) {
-    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (_, i) => () => {
-      return getInferredType(context, i);
+    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference) => () => {
+      return getInferredType(context, inference);
     }));
   }
+  function makeFreeTypeVariableMapperForContext(context) {
+    if (!context.freeTypeVariables)
+      return void 0;
+    const baseMapper = getTypeParameterConstraintMapper(map(context.freeTypeVariables, (i) => i.typeParameter));
+    return context.freeTypeVariables.reduceRight(
+      (previous, i) => combineTypeMappers(makeDeferredTypeMapper([i.typeParameter], [() => hasInferenceCandidatesOrDefault(i) ? getInferredType(context, i) : instantiateType(i.typeParameter, baseMapper)]), previous),
+      baseMapper
+    );
+  }
   function clearCachedInferences(inferences) {
     for (const inference of inferences) {
       if (!inference.isFixed) {
@@ -62388,7 +62363,7 @@ function createTypeChecker(host) {
       for (const { node, type } of context.intraExpressionInferenceSites) {
         const contextualType = node.kind === 171 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
         if (contextualType) {
-          inferTypes(context.inferences, type, contextualType);
+          inferTypes(context, type, contextualType);
         }
       }
       context.intraExpressionInferenceSites = void 0;
@@ -62423,7 +62398,8 @@ function createTypeChecker(host) {
     return inferences.length ? createInferenceContextWorker(map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : void 0;
   }
   function getMapperFromContext(context) {
-    return context && context.mapper;
+    const innerContext = context && last(flattenInferenceContextAlternatives(context));
+    return innerContext && innerContext.mapper && (innerContext.freeTypeVariables ? combineTypeMappers(innerContext.mapper, makeFreeTypeVariableMapperForContext(innerContext)) : innerContext.mapper);
   }
   function couldContainTypeVariables(type) {
     const objectFlags = getObjectFlags(type);
@@ -62523,8 +62499,15 @@ function createTypeChecker(host) {
     const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
     const templateType = getTemplateTypeFromMappedType(target);
     const inference = createInferenceInfo(typeParameter);
-    inferTypes([inference], sourceType, templateType);
-    return getTypeFromInference(inference) || unknownType;
+    const context = createInferenceContextWorker(
+      [inference],
+      /*signature*/
+      void 0,
+      0 /* None */,
+      compareTypesAssignable
+    );
+    inferTypes(context, sourceType, templateType);
+    return getInferredTypes(context, returnFalse)[0] || unknownType;
   }
   function* getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
     const properties = getPropertiesOfType(target);
@@ -62701,7 +62684,15 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
-  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
+  function flattenInferenceContextAlternatives(context) {
+    return context.alternatives ? (context.alternatives.forEach((a) => mergeInferenceContexts(
+      a,
+      context,
+      /*clone*/
+      true
+    )), context.alternatives) : [context];
+  }
+  function inferTypes(context, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
     let inferencePriority = 2048 /* MaxValue */;
@@ -62710,7 +62701,21 @@ function createTypeChecker(host) {
     let sourceStack;
     let targetStack;
     let expandingFlags = 0 /* None */;
+    let useOnlyCachedAlternativeRoutes = false;
     inferFromTypes(originalSource, originalTarget);
+    useOnlyCachedAlternativeRoutes = true;
+    const group2 = forkInferenceContext();
+    spawnAlternativeInferenceContext(
+      group2,
+      () => {
+        if (length(context.freeTypeVariables)) {
+          inferFromTypes(originalSource, instantiateType(originalTarget, context.nonFixingMapper));
+        }
+      },
+      /*fork*/
+      false
+    );
+    joinInferenceContext(group2);
     function inferFromTypes(source, target) {
       if (!couldContainTypeVariables(target)) {
         return;
@@ -62771,6 +62776,9 @@ function createTypeChecker(host) {
           if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
             return;
           }
+          if (useOnlyCachedAlternativeRoutes && source === target) {
+            return;
+          }
           if (!inference.isFixed) {
             if (inference.priority === void 0 || priority < inference.priority) {
               inference.candidates = void 0;
@@ -62783,16 +62791,16 @@ function createTypeChecker(host) {
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
-                  clearCachedInferences(inferences);
+                  clearCachedInferences(context.inferences);
                 }
               } else if (!contains(inference.candidates, candidate)) {
                 inference.candidates = append(inference.candidates, candidate);
-                clearCachedInferences(inferences);
+                clearCachedInferences(context.inferences);
               }
             }
             if (!(priority & 128 /* ReturnType */) && target.flags & 262144 /* TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
               inference.topLevel = false;
-              clearCachedInferences(inferences);
+              clearCachedInferences(context.inferences);
             }
           }
           inferencePriority = Math.min(inferencePriority, priority);
@@ -62960,7 +62968,12 @@ function createTypeChecker(host) {
     }
     function getInferenceInfoForType(type) {
       if (type.flags & 8650752 /* TypeVariable */) {
-        for (const inference of inferences) {
+        for (const inference of context.inferences) {
+          if (type === inference.typeParameter) {
+            return inference;
+          }
+        }
+        for (const inference of context.freeTypeVariables || []) {
           if (type === inference.typeParameter) {
             return inference;
           }
@@ -63241,17 +63254,88 @@ function createTypeChecker(host) {
         }
       }
     }
+    function forkInferenceContext() {
+      return [];
+    }
+    function spawnAlternativeInferenceContext(group3, action, fork = true) {
+      const oldContext = context;
+      flattenInferenceContextAlternatives(context).forEach((alternative) => {
+        const newContext = fork ? cloneInferenceContext(alternative) : alternative;
+        context = newContext;
+        action();
+        context = oldContext;
+        group3.push(...flattenInferenceContextAlternatives(newContext));
+      });
+    }
+    function joinInferenceContext(group3) {
+      group3 = group3.length < 10 ? deduplicate(group3, compareInferenceContext) : group3;
+      if (group3.length === 1) {
+        mergeInferenceContexts(context, group3[0]);
+        context.freeTypeVariables = group3[0].freeTypeVariables;
+        context.freeTypeVariableSourceSignatures = group3[0].freeTypeVariableSourceSignatures;
+        context.inferredTypeParameters = group3[0].inferredTypeParameters;
+        context.flags = group3[0].flags;
+        context.alternatives = void 0;
+        return;
+      }
+      context.alternatives = group3;
+    }
+    function compareInferenceContext(a, b) {
+      return a.compareTypes === b.compareTypes && a.flags === b.flags && a.inferredTypeParameters === b.inferredTypeParameters && a.intraExpressionInferenceSites === b.intraExpressionInferenceSites && a.signature === b.signature && compareInferencesIdentical(a, a.inferences, b, b.inferences) && compareInferencesIdentical(a, a.freeTypeVariables, b, b.freeTypeVariables);
+    }
+    function compareInferencesIdentical(ctxA, a, ctxB, b) {
+      if (length(a) !== length(b))
+        return false;
+      if (length(a) === 0)
+        return true;
+      for (let i = 0; i < length(a); i++) {
+        if (a[i].typeParameter !== b[i].typeParameter || a[i].impliedArity !== b[i].impliedArity || a[i].isFixed !== b[i].isFixed || a[i].priority !== b[i].priority || a[i].topLevel !== b[i].topLevel || forEach(a, (_, i2) => getInferredType(ctxA, a[i2]) !== getInferredType(ctxB, b[i2])))
+          return false;
+      }
+      return true;
+    }
     function inferFromSignatures(source, target, kind) {
+      var _a2, _b;
       const sourceSignatures = getSignaturesOfType(source, kind);
       const targetSignatures = getSignaturesOfType(target, kind);
       const sourceLen = sourceSignatures.length;
       const targetLen = targetSignatures.length;
-      const len = sourceLen < targetLen ? sourceLen : targetLen;
-      for (let i = 0; i < len; i++) {
-        inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
+      if (targetLen === 1 && sourceLen > 1) {
+        const group3 = forkInferenceContext();
+        for (let i = 0; i < sourceLen; i++) {
+          if (useOnlyCachedAlternativeRoutes && !((_b = (_a2 = context.freeTypeVariableSourceSignatures) == null ? void 0 : _a2.get(last(sourceStack))) == null ? void 0 : _b.get(sourceSignatures[i]))) {
+            continue;
+          }
+          spawnAlternativeInferenceContext(
+            group3,
+            () => inferFromSignature(sourceSignatures[i], targetSignatures[0])
+          );
+        }
+        joinInferenceContext(group3);
+      } else {
+        const len = sourceLen < targetLen ? sourceLen : targetLen;
+        for (let i = 0; i < len; i++) {
+          inferFromSignature(sourceSignatures[sourceLen - len + i], targetSignatures[targetLen - len + i]);
+        }
       }
     }
     function inferFromSignature(source, target) {
+      target = getErasedSignature(target);
+      if (source.typeParameters) {
+        let cache = (context.freeTypeVariableSourceSignatures || (context.freeTypeVariableSourceSignatures = /* @__PURE__ */ new Map())).get(last(sourceStack));
+        if (!cache) {
+          context.freeTypeVariableSourceSignatures.set(last(sourceStack), cache = /* @__PURE__ */ new Map());
+        }
+        const cached = cache.get(source);
+        if (cached) {
+          source = cached;
+        } else {
+          const originalSignature = source;
+          source = instantiateSignature(source, makeUnaryTypeMapper(unknownType, unknownType));
+          cache.set(originalSignature, source);
+          (context.freeTypeVariables || (context.freeTypeVariables = [])).push(...map(source.typeParameters, createInferenceInfo));
+        }
+      }
       const saveBivariant = bivariant;
       const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
       bivariant = bivariant || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 173 /* Constructor */;
@@ -63326,8 +63410,7 @@ function createTypeChecker(host) {
     const unwidenedType = inference.priority & 416 /* PriorityImpliesCombination */ ? getUnionType(baseCandidates, 2 /* Subtype */) : getCommonSupertype(baseCandidates);
     return getWidenedType(unwidenedType);
   }
-  function getInferredType(context, index) {
-    const inference = context.inferences[index];
+  function getInferredType(context, inference) {
     if (!inference.inferredType) {
       let inferredType;
       const signature = context.signature;
@@ -63343,7 +63426,7 @@ function createTypeChecker(host) {
         } else {
           const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
           if (defaultType) {
-            inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
+            inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, inference), context.nonFixingMapper));
           }
         }
       } else {
@@ -63363,12 +63446,24 @@ function createTypeChecker(host) {
   function getDefaultTypeArgumentType(isInJavaScriptFile) {
     return isInJavaScriptFile ? anyType : unknownType;
   }
-  function getInferredTypes(context) {
-    const result = [];
-    for (let i = 0; i < context.inferences.length; i++) {
-      result.push(getInferredType(context, i));
+  function getInferredTypes(context, accept) {
+    const alternatives = flattenInferenceContextAlternatives(context);
+    let finalAlternative;
+    for (let a = alternatives.length - 1; a >= 0; a--) {
+      const context2 = alternatives[a];
+      const freeTypeVariableMapper = makeFreeTypeVariableMapperForContext(context2);
+      const result = [];
+      for (const inference of context2.inferences) {
+        result.push(instantiateType(getInferredType(context2, inference), freeTypeVariableMapper));
+      }
+      if (alternatives.length === 1 || accept(result)) {
+        return result;
+      }
+      if (!finalAlternative) {
+        finalAlternative = result;
+      }
     }
-    return result;
+    return finalAlternative;
   }
   function getCannotFindNameDiagnosticForName(node) {
     switch (node.escapedText) {
@@ -66746,8 +66841,11 @@ function createTypeChecker(host) {
   function instantiateContextualType(contextualType, node, contextFlags) {
     if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* Instantiable */)) {
       const inferenceContext = getInferenceContext(node);
-      if (inferenceContext && contextFlags & 1 /* Signature */ && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
-        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+      if (inferenceContext && contextFlags & 1 /* Signature */ && some(flatMap(flattenInferenceContextAlternatives(inferenceContext), (c) => c.inferences), hasInferenceCandidatesOrDefault)) {
+        return getUnionType(map(
+          flattenInferenceContextAlternatives(inferenceContext),
+          (c) => instantiateInstantiableTypes(contextualType, c.nonFixingMapper)
+        ));
       }
       if (inferenceContext == null ? void 0 : inferenceContext.returnMapper) {
         const type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
@@ -69106,23 +69204,23 @@ function createTypeChecker(host) {
   function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
     const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
     const restType = getEffectiveRestType(contextualSignature);
-    const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
+    const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : getMapperFromContext(inferenceContext));
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
     applyToParameterTypes(sourceSignature, signature, (source, target) => {
-      inferTypes(context.inferences, source, target);
+      inferTypes(context, source, target);
     });
     if (!inferenceContext) {
       applyToReturnTypes(contextualSignature, signature, (source, target) => {
-        inferTypes(context.inferences, source, target, 128 /* ReturnType */);
+        inferTypes(context, source, target, 128 /* ReturnType */);
       });
     }
-    return getSignatureInstantiation(signature, getInferredTypes(context), isInJSFile(contextualSignature.declaration));
+    return getSignatureInstantiation(signature, getInferredTypes(context, returnFalse), isInJSFile(contextualSignature.declaration));
   }
-  function inferJsxTypeArguments(node, signature, checkMode, context) {
+  function inferJsxTypeArguments(node, signature, checkMode, context, accept) {
     const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
     const checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
-    inferTypes(context.inferences, checkAttrType, paramType);
-    return getInferredTypes(context);
+    inferTypes(context, checkAttrType, paramType);
+    return getInferredTypes(context, accept);
   }
   function getThisArgumentType(thisArgumentNode) {
     if (!thisArgumentNode) {
@@ -69131,9 +69229,9 @@ function createTypeChecker(host) {
     const thisArgumentType = checkExpression(thisArgumentNode);
     return isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : thisArgumentType;
   }
-  function inferTypeArguments(node, signature, args, checkMode, context) {
+  function inferTypeArguments(node, signature, args, checkMode, context, accept) {
     if (isJsxOpeningLikeElement(node)) {
-      return inferJsxTypeArguments(node, signature, checkMode, context);
+      return inferJsxTypeArguments(node, signature, checkMode, context, accept);
     }
     if (node.kind !== 167 /* Decorator */) {
       const skipBindingPatterns = every(signature.typeParameters, (p) => !!getDefaultFromTypeParameter(p));
@@ -69148,11 +69246,11 @@ function createTypeChecker(host) {
             const instantiatedType = instantiateType(contextualType, outerMapper);
             const contextualSignature = getSingleCallSignature(instantiatedType);
             const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : instantiatedType;
-            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+            inferTypes(context, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
           }
           const returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
           const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
-          inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
+          inferTypes(returnContext, returnSourceType, inferenceTargetType);
           context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : void 0;
         }
       }
@@ -69168,7 +69266,7 @@ function createTypeChecker(host) {
     const thisType = getThisTypeOfSignature(signature);
     if (thisType && couldContainTypeVariables(thisType)) {
       const thisArgumentNode = getThisArgumentOfCall(node);
-      inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
+      inferTypes(context, getThisArgumentType(thisArgumentNode), thisType);
     }
     for (let i = 0; i < argCount; i++) {
       const arg = args[i];
@@ -69176,15 +69274,15 @@ function createTypeChecker(host) {
         const paramType = getTypeAtPosition(signature, i);
         if (couldContainTypeVariables(paramType)) {
           const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
-          inferTypes(context.inferences, argType, paramType);
+          inferTypes(context, argType, paramType);
         }
       }
     }
     if (restType && couldContainTypeVariables(restType)) {
       const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
-      inferTypes(context.inferences, spreadType, restType);
+      inferTypes(context, spreadType, restType);
     }
-    return getInferredTypes(context);
+    return getInferredTypes(context, accept);
   }
   function getMutableArrayOrTupleType(type) {
     return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(
@@ -69951,6 +70049,26 @@ function createTypeChecker(host) {
         }
         let checkCandidate;
         let inferenceContext;
+        const acceptor = (types) => {
+          const checkCandidate2 = getSignatureInstantiation(candidate, types, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+          if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate2, signatureHelpTrailingComma2)) {
+            return false;
+          }
+          if (getSignatureApplicabilityError(
+            node,
+            args,
+            checkCandidate2,
+            relation,
+            argCheckMode,
+            /*reportErrors*/
+            false,
+            /*containingMessageChain*/
+            void 0
+          )) {
+            return false;
+          }
+          return true;
+        };
         if (candidate.typeParameters) {
           let typeArgumentTypes;
           if (some(typeArguments)) {
@@ -69971,7 +70089,7 @@ function createTypeChecker(host) {
               /*flags*/
               isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
             );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
+            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext, acceptor);
             argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
           }
           checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -69999,7 +70117,7 @@ function createTypeChecker(host) {
         if (argCheckMode) {
           argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
           if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext, acceptor);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
@@ -70109,7 +70227,7 @@ function createTypeChecker(host) {
       /*flags*/
       isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
     );
-    const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
+    const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext, returnFalse);
     return createSignatureInstantiation(candidate, typeArgumentTypes);
   }
   function getLongestCandidateIndex(candidates, argsCount) {
@@ -71377,7 +71495,7 @@ function createTypeChecker(host) {
       if (declaration.type) {
         const typeNode = getEffectiveTypeAnnotationNode(declaration);
         if (typeNode) {
-          inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
+          inferTypes(inferenceContext, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
         }
       }
     }
@@ -72089,7 +72207,7 @@ function createTypeChecker(host) {
                 instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
               }
             }
-            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
+            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, getMapperFromContext(inferenceContext)) : contextualSignature);
             assignContextualParameterTypes(signature, instantiatedContextualSignature);
           } else {
             assignNonContextualParameterTypes(signature);
@@ -73470,7 +73588,7 @@ function createTypeChecker(host) {
     return isAssertionExpression(parent) && isConstTypeReference(parent.type) || isJSDocTypeAssertion(parent) && isConstTypeReference(getJSDocTypeAssertionType(parent)) || isValidConstAssertionArgument(node) && isConstTypeParameterContext(node) || (isParenthesizedExpression(parent) || isArrayLiteralExpression(parent) || isSpreadElement(parent)) && isConstContext(parent) || (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
   }
   function isConstTypeParameterContext(node) {
-    const contextualType = getContextualType(node, 0 /* None */);
+    const contextualType = getContextualType(node, 1 /* Signature */);
     return !!contextualType && someType(contextualType, isConstTypeVariable);
   }
   function checkExpressionForMutableLocation(node, checkMode, forceTuple) {
@@ -73535,10 +73653,11 @@ function createTypeChecker(host) {
             if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
               const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
               const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
-              const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
+              const subcontext = cloneInferenceContext(context);
+              subcontext.inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
               applyToParameterTypes(instantiatedSignature, contextualSignature, (source, target) => {
                 inferTypes(
-                  inferences,
+                  subcontext,
                   source,
                   target,
                   /*priority*/
@@ -73547,12 +73666,12 @@ function createTypeChecker(host) {
                   true
                 );
               });
-              if (some(inferences, hasInferenceCandidates)) {
+              if (some(subcontext.inferences, hasInferenceCandidates)) {
                 applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
-                  inferTypes(inferences, source, target);
+                  inferTypes(subcontext, source, target);
                 });
-                if (!hasOverlappingInferences(context.inferences, inferences)) {
-                  mergeInferences(context.inferences, inferences);
+                if (!hasOverlappingInferences(context.inferences, subcontext.inferences)) {
+                  mergeInferenceContexts(context, subcontext);
                   context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
                   return getOrCreateTypeFromSignature(instantiatedSignature);
                 }
@@ -73585,13 +73704,22 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function mergeInferences(target, source) {
+  function mergeInferences(target, source, clone2 = false) {
     for (let i = 0; i < target.length; i++) {
       if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
-        target[i] = source[i];
+        target[i] = clone2 ? {
+          ...source[i],
+          candidates: source[i].candidates && [...source[i].candidates],
+          contraCandidates: source[i].contraCandidates && [...source[i].contraCandidates]
+        } : source[i];
       }
     }
   }
+  function mergeInferenceContexts(target, source, cloneInferences = false) {
+    mergeInferences(target.inferences, source.inferences, cloneInferences);
+    target.mapper = makeFixingMapperForContext(target);
+    target.nonFixingMapper = makeNonFixingMapperForContext(target);
+  }
   function getUniqueTypeParameters(context, typeParameters) {
     const result = [];
     let oldTypeParameters;
@@ -93088,7 +93216,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,
@@ -93220,7 +93348,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);
@@ -114560,7 +114688,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     const result = getImpliedNodeFormatForFileWorker(getNormalizedAbsolutePath(fileName, currentDirectory), moduleResolutionCache2 == null ? void 0 : moduleResolutionCache2.getPackageJsonInfoCache(), host2, options2);
     const languageVersion = getEmitScriptTarget(options2);
     const setExternalModuleIndicator2 = getSetExternalModuleIndicator(options2);
-    return typeof result === "object" ? { ...result, languageVersion, setExternalModuleIndicator: setExternalModuleIndicator2, skipJSDoc: options2.skipJSDocParsing } : { languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator2, skipJSDoc: options2.skipJSDocParsing };
+    return typeof result === "object" ? { ...result, languageVersion, setExternalModuleIndicator: setExternalModuleIndicator2 } : { languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator2 };
   }
   function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
     var _a3, _b2;
@@ -121962,8 +122090,7 @@ function shouldBePretty(sys2, options) {
   return options.pretty;
 }
 function getOptionsForHelp(commandLine) {
-  const filtered = filter(optionDeclarations.slice(), (v) => !v.hiddenInAllViews && (!!commandLine.options.all || !!v.showInSimplifiedHelpView));
-  return !!commandLine.options.all ? sort(filtered, (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filtered;
+  return !!commandLine.options.all ? sort(optionDeclarations, (a, b) => compareStringsCaseInsensitive(a.name, b.name)) : filter(optionDeclarations.slice(), (v) => !!v.showInSimplifiedHelpView);
 }
 function printVersion(sys2) {
   sys2.write(getDiagnosticText(Diagnostics.Version_0, version) + sys2.newLine);
@@ -123070,6 +123197,5 @@ if (sys.tryEnableSourceMapsForHost && /^development$/i.test(sys.getEnvironmentVa
 if (sys.setBlocking) {
   sys.setBlocking();
 }
-sys.args.push("--skipJSDocParsing");
 executeCommandLine(sys, noop, sys.args);
 //# sourceMappingURL=tsc.js.map