typescript 4.6.0-dev.20211102 → 4.6.0-dev.20211106

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211102";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211106";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4994,6 +4994,7 @@ var ts;
         NodeCheckFlags[NodeCheckFlags["ConstructorReferenceInClass"] = 33554432] = "ConstructorReferenceInClass";
         NodeCheckFlags[NodeCheckFlags["ContainsClassWithPrivateIdentifiers"] = 67108864] = "ContainsClassWithPrivateIdentifiers";
         NodeCheckFlags[NodeCheckFlags["ContainsSuperPropertyInStaticInitializer"] = 134217728] = "ContainsSuperPropertyInStaticInitializer";
+        NodeCheckFlags[NodeCheckFlags["InCheckIdentifier"] = 268435456] = "InCheckIdentifier";
     })(NodeCheckFlags = ts.NodeCheckFlags || (ts.NodeCheckFlags = {}));
     var TypeFlags;
     (function (TypeFlags) {
@@ -5067,8 +5068,6 @@ var ts;
         // 'Narrowable' types are types where narrowing actually narrows.
         // This *should* be every type other than null, undefined, void, and never
         TypeFlags[TypeFlags["Narrowable"] = 536624127] = "Narrowable";
-        /* @internal */
-        TypeFlags[TypeFlags["NotPrimitiveUnion"] = 468598819] = "NotPrimitiveUnion";
         // The following flags are aggregated during union and intersection type construction
         /* @internal */
         TypeFlags[TypeFlags["IncludesMask"] = 205258751] = "IncludesMask";
@@ -5081,6 +5080,10 @@ var ts;
         TypeFlags[TypeFlags["IncludesWildcard"] = 8388608] = "IncludesWildcard";
         /* @internal */
         TypeFlags[TypeFlags["IncludesEmptyObject"] = 16777216] = "IncludesEmptyObject";
+        /* @internal */
+        TypeFlags[TypeFlags["IncludesInstantiable"] = 33554432] = "IncludesInstantiable";
+        /* @internal */
+        TypeFlags[TypeFlags["NotPrimitiveUnion"] = 36323363] = "NotPrimitiveUnion";
     })(TypeFlags = ts.TypeFlags || (ts.TypeFlags = {}));
     // Types included in TypeFlags.ObjectFlagsType have an objectFlags property. Some ObjectFlags
     // are specific to certain types and reuse the same bit position. Those ObjectFlags require a check
@@ -5414,6 +5417,7 @@ var ts;
         ScriptTarget[ScriptTarget["ES2019"] = 6] = "ES2019";
         ScriptTarget[ScriptTarget["ES2020"] = 7] = "ES2020";
         ScriptTarget[ScriptTarget["ES2021"] = 8] = "ES2021";
+        ScriptTarget[ScriptTarget["ES2022"] = 9] = "ES2022";
         ScriptTarget[ScriptTarget["ESNext"] = 99] = "ESNext";
         ScriptTarget[ScriptTarget["JSON"] = 100] = "JSON";
         ScriptTarget[ScriptTarget["Latest"] = 99] = "Latest";
@@ -5582,15 +5586,16 @@ var ts;
         TransformFlags[TransformFlags["ContainsTypeScript"] = 1] = "ContainsTypeScript";
         TransformFlags[TransformFlags["ContainsJsx"] = 2] = "ContainsJsx";
         TransformFlags[TransformFlags["ContainsESNext"] = 4] = "ContainsESNext";
-        TransformFlags[TransformFlags["ContainsES2021"] = 8] = "ContainsES2021";
-        TransformFlags[TransformFlags["ContainsES2020"] = 16] = "ContainsES2020";
-        TransformFlags[TransformFlags["ContainsES2019"] = 32] = "ContainsES2019";
-        TransformFlags[TransformFlags["ContainsES2018"] = 64] = "ContainsES2018";
-        TransformFlags[TransformFlags["ContainsES2017"] = 128] = "ContainsES2017";
-        TransformFlags[TransformFlags["ContainsES2016"] = 256] = "ContainsES2016";
-        TransformFlags[TransformFlags["ContainsES2015"] = 512] = "ContainsES2015";
-        TransformFlags[TransformFlags["ContainsGenerator"] = 1024] = "ContainsGenerator";
-        TransformFlags[TransformFlags["ContainsDestructuringAssignment"] = 2048] = "ContainsDestructuringAssignment";
+        TransformFlags[TransformFlags["ContainsES2022"] = 8] = "ContainsES2022";
+        TransformFlags[TransformFlags["ContainsES2021"] = 16] = "ContainsES2021";
+        TransformFlags[TransformFlags["ContainsES2020"] = 32] = "ContainsES2020";
+        TransformFlags[TransformFlags["ContainsES2019"] = 64] = "ContainsES2019";
+        TransformFlags[TransformFlags["ContainsES2018"] = 128] = "ContainsES2018";
+        TransformFlags[TransformFlags["ContainsES2017"] = 256] = "ContainsES2017";
+        TransformFlags[TransformFlags["ContainsES2016"] = 512] = "ContainsES2016";
+        TransformFlags[TransformFlags["ContainsES2015"] = 1024] = "ContainsES2015";
+        TransformFlags[TransformFlags["ContainsGenerator"] = 2048] = "ContainsGenerator";
+        TransformFlags[TransformFlags["ContainsDestructuringAssignment"] = 4096] = "ContainsDestructuringAssignment";
         // Markers
         // - Flags used to indicate that a subtree contains a specific transformation.
         TransformFlags[TransformFlags["ContainsTypeScriptClassSyntax"] = 4096] = "ContainsTypeScriptClassSyntax";
@@ -5617,15 +5622,16 @@ var ts;
         TransformFlags[TransformFlags["AssertTypeScript"] = 1] = "AssertTypeScript";
         TransformFlags[TransformFlags["AssertJsx"] = 2] = "AssertJsx";
         TransformFlags[TransformFlags["AssertESNext"] = 4] = "AssertESNext";
-        TransformFlags[TransformFlags["AssertES2021"] = 8] = "AssertES2021";
-        TransformFlags[TransformFlags["AssertES2020"] = 16] = "AssertES2020";
-        TransformFlags[TransformFlags["AssertES2019"] = 32] = "AssertES2019";
-        TransformFlags[TransformFlags["AssertES2018"] = 64] = "AssertES2018";
-        TransformFlags[TransformFlags["AssertES2017"] = 128] = "AssertES2017";
-        TransformFlags[TransformFlags["AssertES2016"] = 256] = "AssertES2016";
-        TransformFlags[TransformFlags["AssertES2015"] = 512] = "AssertES2015";
-        TransformFlags[TransformFlags["AssertGenerator"] = 1024] = "AssertGenerator";
-        TransformFlags[TransformFlags["AssertDestructuringAssignment"] = 2048] = "AssertDestructuringAssignment";
+        TransformFlags[TransformFlags["AssertES2022"] = 8] = "AssertES2022";
+        TransformFlags[TransformFlags["AssertES2021"] = 16] = "AssertES2021";
+        TransformFlags[TransformFlags["AssertES2020"] = 32] = "AssertES2020";
+        TransformFlags[TransformFlags["AssertES2019"] = 64] = "AssertES2019";
+        TransformFlags[TransformFlags["AssertES2018"] = 128] = "AssertES2018";
+        TransformFlags[TransformFlags["AssertES2017"] = 256] = "AssertES2017";
+        TransformFlags[TransformFlags["AssertES2016"] = 512] = "AssertES2016";
+        TransformFlags[TransformFlags["AssertES2015"] = 1024] = "AssertES2015";
+        TransformFlags[TransformFlags["AssertGenerator"] = 2048] = "AssertGenerator";
+        TransformFlags[TransformFlags["AssertDestructuringAssignment"] = 4096] = "AssertDestructuringAssignment";
         // Scope Exclusions
         // - Bitmasks that exclude flags from propagating out of a specific context
         //   into the subtree flags of their container.
@@ -8295,7 +8301,7 @@ var ts;
         Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
         Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
-        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext'."),
+        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
         Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
         String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
@@ -8895,11 +8901,12 @@ var ts;
         Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: diag(2818, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."),
         Namespace_name_cannot_be_0: diag(2819, ts.DiagnosticCategory.Error, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."),
         Type_0_is_not_assignable_to_type_1_Did_you_mean_2: diag(2820, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"),
-        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext'."),
+        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'."),
         Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, ts.DiagnosticCategory.Error, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
         Cannot_find_namespace_0_Did_you_mean_1: diag(2833, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Consider adding an extension to the import path."),
         Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?"),
+        Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -11926,6 +11933,7 @@ var ts;
                     tokenValue = tokenValue.slice(0, -1);
                     pos--;
                 }
+                return getIdentifierToken();
             }
             return token;
         }
@@ -12171,6 +12179,8 @@ var ts;
         switch (ts.getEmitScriptTarget(options)) {
             case 99 /* ESNext */:
                 return "lib.esnext.full.d.ts";
+            case 9 /* ES2022 */:
+                return "lib.es2022.full.d.ts";
             case 8 /* ES2021 */:
                 return "lib.es2021.full.d.ts";
             case 7 /* ES2020 */:
@@ -14637,6 +14647,7 @@ var ts;
                 AsyncIterableIterator: ts.emptyArray,
                 AsyncGenerator: ts.emptyArray,
                 AsyncGeneratorFunction: ts.emptyArray,
+                NumberFormat: ["formatToParts"]
             },
             es2019: {
                 Array: ["flat", "flatMap"],
@@ -14658,8 +14669,21 @@ var ts;
                 PromiseConstructor: ["any"],
                 String: ["replaceAll"]
             },
-            esnext: {
-                NumberFormat: ["formatToParts"]
+            es2022: {
+                Array: ["at"],
+                String: ["at"],
+                Int8Array: ["at"],
+                Uint8Array: ["at"],
+                Uint8ClampedArray: ["at"],
+                Int16Array: ["at"],
+                Uint16Array: ["at"],
+                Int32Array: ["at"],
+                Uint32Array: ["at"],
+                Float32Array: ["at"],
+                Float64Array: ["at"],
+                BigInt64Array: ["at"],
+                BigUint64Array: ["at"],
+                ObjectConstructor: ["hasOwn"]
             }
         };
     }
@@ -22199,7 +22223,7 @@ var ts;
             var node = createBaseLiteral(8 /* NumericLiteral */, typeof value === "number" ? value + "" : value);
             node.numericLiteralFlags = numericLiteralFlags;
             if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
-                node.transformFlags |= 512 /* ContainsES2015 */;
+                node.transformFlags |= 1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -22218,7 +22242,7 @@ var ts;
             var node = createBaseStringLiteral(text, isSingleQuote);
             node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
             if (hasExtendedUnicodeEscape)
-                node.transformFlags |= 512 /* ContainsES2015 */;
+                node.transformFlags |= 1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -22346,8 +22370,8 @@ var ts;
                 case 131 /* AsyncKeyword */:
                     // 'async' modifier is ES2017 (async functions) or ES2018 (async generators)
                     transformFlags =
-                        128 /* ContainsES2017 */ |
-                            64 /* ContainsES2018 */;
+                        256 /* ContainsES2017 */ |
+                            128 /* ContainsES2018 */;
                     break;
                 case 123 /* PublicKeyword */:
                 case 121 /* PrivateKeyword */:
@@ -22371,10 +22395,10 @@ var ts;
                     transformFlags = 1 /* ContainsTypeScript */;
                     break;
                 case 106 /* SuperKeyword */:
-                    transformFlags = 512 /* ContainsES2015 */ | 33554432 /* ContainsLexicalSuper */;
+                    transformFlags = 1024 /* ContainsES2015 */ | 33554432 /* ContainsLexicalSuper */;
                     break;
                 case 124 /* StaticKeyword */:
-                    transformFlags = 512 /* ContainsES2015 */;
+                    transformFlags = 1024 /* ContainsES2015 */;
                     break;
                 case 108 /* ThisKeyword */:
                     // 'this' indicates a lexical 'this'
@@ -22471,7 +22495,7 @@ var ts;
             node.expression = parenthesizerRules().parenthesizeExpressionOfComputedPropertyName(expression);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
-                    512 /* ContainsES2015 */ |
+                    1024 /* ContainsES2015 */ |
                     65536 /* ContainsComputedPropertyName */;
             return node;
         }
@@ -22519,7 +22543,7 @@ var ts;
                 if (ts.modifiersToFlags(node.modifiers) & 16476 /* ParameterPropertyModifier */)
                     node.transformFlags |= 4096 /* ContainsTypeScriptClassSyntax */;
                 if (initializer || dotDotDotToken)
-                    node.transformFlags |= 512 /* ContainsES2015 */;
+                    node.transformFlags |= 1024 /* ContainsES2015 */;
             }
             return node;
         }
@@ -22628,20 +22652,20 @@ var ts;
             node.transformFlags |=
                 propagateChildFlags(node.asteriskToken) |
                     propagateChildFlags(node.questionToken) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             if (questionToken) {
                 node.transformFlags |= 1 /* ContainsTypeScript */;
             }
             if (ts.modifiersToFlags(node.modifiers) & 256 /* Async */) {
                 if (asteriskToken) {
-                    node.transformFlags |= 64 /* ContainsES2018 */;
+                    node.transformFlags |= 128 /* ContainsES2018 */;
                 }
                 else {
-                    node.transformFlags |= 128 /* ContainsES2017 */;
+                    node.transformFlags |= 256 /* ContainsES2017 */;
                 }
             }
             else if (asteriskToken) {
-                node.transformFlags |= 1024 /* ContainsGenerator */;
+                node.transformFlags |= 2048 /* ContainsGenerator */;
             }
             return node;
         }
@@ -22682,7 +22706,7 @@ var ts;
             /*name*/ undefined, 
             /*typeParameters*/ undefined, parameters, 
             /*type*/ undefined, body);
-            node.transformFlags |= 512 /* ContainsES2015 */;
+            node.transformFlags |= 1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -23176,11 +23200,11 @@ var ts;
             node.elements = createNodeArray(elements);
             node.transformFlags |=
                 propagateChildrenFlags(node.elements) |
-                    512 /* ContainsES2015 */ |
+                    1024 /* ContainsES2015 */ |
                     262144 /* ContainsBindingPattern */;
             if (node.transformFlags & 16384 /* ContainsRestOrSpread */) {
                 node.transformFlags |=
-                    64 /* ContainsES2018 */ |
+                    128 /* ContainsES2018 */ |
                         32768 /* ContainsObjectRestOrSpread */;
             }
             return node;
@@ -23197,7 +23221,7 @@ var ts;
             node.elements = createNodeArray(elements);
             node.transformFlags |=
                 propagateChildrenFlags(node.elements) |
-                    512 /* ContainsES2015 */ |
+                    1024 /* ContainsES2015 */ |
                     262144 /* ContainsBindingPattern */;
             return node;
         }
@@ -23216,7 +23240,7 @@ var ts;
             node.dotDotDotToken = dotDotDotToken;
             node.transformFlags |=
                 propagateChildFlags(node.dotDotDotToken) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             if (node.propertyName) {
                 node.transformFlags |= ts.isIdentifier(node.propertyName) ?
                     propagateIdentifierNameFlags(node.propertyName) :
@@ -23290,8 +23314,8 @@ var ts;
                 // super method calls require a lexical 'this'
                 // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators
                 node.transformFlags |=
-                    128 /* ContainsES2017 */ |
-                        64 /* ContainsES2018 */;
+                    256 /* ContainsES2017 */ |
+                        128 /* ContainsES2018 */;
             }
             return node;
         }
@@ -23313,7 +23337,7 @@ var ts;
             node.questionDotToken = questionDotToken;
             node.name = asName(name);
             node.transformFlags |=
-                16 /* ContainsES2020 */ |
+                32 /* ContainsES2020 */ |
                     propagateChildFlags(node.expression) |
                     propagateChildFlags(node.questionDotToken) |
                     (ts.isIdentifier(node.name) ?
@@ -23344,8 +23368,8 @@ var ts;
                 // super method calls require a lexical 'this'
                 // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators
                 node.transformFlags |=
-                    128 /* ContainsES2017 */ |
-                        64 /* ContainsES2018 */;
+                    256 /* ContainsES2017 */ |
+                        128 /* ContainsES2018 */;
             }
             return node;
         }
@@ -23370,7 +23394,7 @@ var ts;
                 propagateChildFlags(node.expression) |
                     propagateChildFlags(node.questionDotToken) |
                     propagateChildFlags(node.argumentExpression) |
-                    16 /* ContainsES2020 */;
+                    32 /* ContainsES2020 */;
             return node;
         }
         // @api
@@ -23429,7 +23453,7 @@ var ts;
                     propagateChildFlags(node.questionDotToken) |
                     propagateChildrenFlags(node.typeArguments) |
                     propagateChildrenFlags(node.arguments) |
-                    16 /* ContainsES2020 */;
+                    32 /* ContainsES2020 */;
             if (node.typeArguments) {
                 node.transformFlags |= 1 /* ContainsTypeScript */;
             }
@@ -23458,7 +23482,7 @@ var ts;
                 propagateChildFlags(node.expression) |
                     propagateChildrenFlags(node.typeArguments) |
                     propagateChildrenFlags(node.arguments) |
-                    16 /* ContainsES2020 */;
+                    32 /* ContainsES2020 */;
             if (node.typeArguments) {
                 node.transformFlags |= 1 /* ContainsTypeScript */;
             }
@@ -23482,12 +23506,12 @@ var ts;
                 propagateChildFlags(node.tag) |
                     propagateChildrenFlags(node.typeArguments) |
                     propagateChildFlags(node.template) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             if (node.typeArguments) {
                 node.transformFlags |= 1 /* ContainsTypeScript */;
             }
             if (ts.hasInvalidEscape(node.template)) {
-                node.transformFlags |= 64 /* ContainsES2018 */;
+                node.transformFlags |= 128 /* ContainsES2018 */;
             }
             return node;
         }
@@ -23541,14 +23565,14 @@ var ts;
             }
             if (ts.modifiersToFlags(node.modifiers) & 256 /* Async */) {
                 if (node.asteriskToken) {
-                    node.transformFlags |= 64 /* ContainsES2018 */;
+                    node.transformFlags |= 128 /* ContainsES2018 */;
                 }
                 else {
-                    node.transformFlags |= 128 /* ContainsES2017 */;
+                    node.transformFlags |= 256 /* ContainsES2017 */;
                 }
             }
             else if (node.asteriskToken) {
-                node.transformFlags |= 1024 /* ContainsGenerator */;
+                node.transformFlags |= 2048 /* ContainsGenerator */;
             }
             return node;
         }
@@ -23572,9 +23596,9 @@ var ts;
             node.equalsGreaterThanToken = equalsGreaterThanToken !== null && equalsGreaterThanToken !== void 0 ? equalsGreaterThanToken : createToken(38 /* EqualsGreaterThanToken */);
             node.transformFlags |=
                 propagateChildFlags(node.equalsGreaterThanToken) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             if (ts.modifiersToFlags(node.modifiers) & 256 /* Async */) {
-                node.transformFlags |= 128 /* ContainsES2017 */ | 8192 /* ContainsLexicalThis */;
+                node.transformFlags |= 256 /* ContainsES2017 */ | 8192 /* ContainsLexicalThis */;
             }
             return node;
         }
@@ -23634,8 +23658,8 @@ var ts;
             node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
-                    128 /* ContainsES2017 */ |
-                    64 /* ContainsES2018 */ |
+                    256 /* ContainsES2017 */ |
+                    128 /* ContainsES2018 */ |
                     1048576 /* ContainsAwait */;
             return node;
         }
@@ -23701,35 +23725,35 @@ var ts;
                     propagateChildFlags(node.operatorToken) |
                     propagateChildFlags(node.right);
             if (operatorKind === 60 /* QuestionQuestionToken */) {
-                node.transformFlags |= 16 /* ContainsES2020 */;
+                node.transformFlags |= 32 /* ContainsES2020 */;
             }
             else if (operatorKind === 63 /* EqualsToken */) {
                 if (ts.isObjectLiteralExpression(node.left)) {
                     node.transformFlags |=
-                        512 /* ContainsES2015 */ |
-                            64 /* ContainsES2018 */ |
-                            2048 /* ContainsDestructuringAssignment */ |
+                        1024 /* ContainsES2015 */ |
+                            128 /* ContainsES2018 */ |
+                            4096 /* ContainsDestructuringAssignment */ |
                             propagateAssignmentPatternFlags(node.left);
                 }
                 else if (ts.isArrayLiteralExpression(node.left)) {
                     node.transformFlags |=
-                        512 /* ContainsES2015 */ |
-                            2048 /* ContainsDestructuringAssignment */ |
+                        1024 /* ContainsES2015 */ |
+                            4096 /* ContainsDestructuringAssignment */ |
                             propagateAssignmentPatternFlags(node.left);
                 }
             }
             else if (operatorKind === 42 /* AsteriskAsteriskToken */ || operatorKind === 67 /* AsteriskAsteriskEqualsToken */) {
-                node.transformFlags |= 256 /* ContainsES2016 */;
+                node.transformFlags |= 512 /* ContainsES2016 */;
             }
             else if (ts.isLogicalOrCoalescingAssignmentOperator(operatorKind)) {
-                node.transformFlags |= 8 /* ContainsES2021 */;
+                node.transformFlags |= 16 /* ContainsES2021 */;
             }
             return node;
         }
         function propagateAssignmentPatternFlags(node) {
             if (node.transformFlags & 32768 /* ContainsObjectRestOrSpread */)
                 return 32768 /* ContainsObjectRestOrSpread */;
-            if (node.transformFlags & 64 /* ContainsES2018 */) {
+            if (node.transformFlags & 128 /* ContainsES2018 */) {
                 // check for nested spread assignments, otherwise '{ x: { a, ...b } = foo } = c'
                 // will not be correctly interpreted by the ES2018 transformer
                 for (var _i = 0, _a = ts.getElementsOfBindingOrAssignmentPattern(node); _i < _a.length; _i++) {
@@ -23739,7 +23763,7 @@ var ts;
                         if (target.transformFlags & 32768 /* ContainsObjectRestOrSpread */) {
                             return 32768 /* ContainsObjectRestOrSpread */;
                         }
-                        if (target.transformFlags & 64 /* ContainsES2018 */) {
+                        if (target.transformFlags & 128 /* ContainsES2018 */) {
                             var flags_1 = propagateAssignmentPatternFlags(target);
                             if (flags_1)
                                 return flags_1;
@@ -23791,7 +23815,7 @@ var ts;
             node.transformFlags |=
                 propagateChildFlags(node.head) |
                     propagateChildrenFlags(node.templateSpans) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -23830,9 +23854,9 @@ var ts;
             node.text = text;
             node.rawText = rawText;
             node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
-            node.transformFlags |= 512 /* ContainsES2015 */;
+            node.transformFlags |= 1024 /* ContainsES2015 */;
             if (node.templateFlags) {
-                node.transformFlags |= 64 /* ContainsES2018 */;
+                node.transformFlags |= 128 /* ContainsES2018 */;
             }
             return node;
         }
@@ -23861,8 +23885,8 @@ var ts;
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                     propagateChildFlags(node.asteriskToken) |
-                    512 /* ContainsES2015 */ |
-                    64 /* ContainsES2018 */ |
+                    1024 /* ContainsES2015 */ |
+                    128 /* ContainsES2018 */ |
                     524288 /* ContainsYield */;
             return node;
         }
@@ -23879,7 +23903,7 @@ var ts;
             node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
-                    512 /* ContainsES2015 */ |
+                    1024 /* ContainsES2015 */ |
                     16384 /* ContainsRestOrSpread */;
             return node;
         }
@@ -23892,7 +23916,7 @@ var ts;
         // @api
         function createClassExpression(decorators, modifiers, name, typeParameters, heritageClauses, members) {
             var node = createBaseClassLikeDeclaration(225 /* ClassExpression */, decorators, modifiers, name, typeParameters, heritageClauses, members);
-            node.transformFlags |= 512 /* ContainsES2015 */;
+            node.transformFlags |= 1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -23918,7 +23942,7 @@ var ts;
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                     propagateChildrenFlags(node.typeArguments) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -23989,7 +24013,7 @@ var ts;
             node.transformFlags |= propagateChildFlags(node.name);
             switch (keywordToken) {
                 case 103 /* NewKeyword */:
-                    node.transformFlags |= 512 /* ContainsES2015 */;
+                    node.transformFlags |= 1024 /* ContainsES2015 */;
                     break;
                 case 100 /* ImportKeyword */:
                     node.transformFlags |= 4 /* ContainsESNext */;
@@ -24016,7 +24040,7 @@ var ts;
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                     propagateChildFlags(node.literal) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             return node;
         }
         // @api
@@ -24029,7 +24053,7 @@ var ts;
         // @api
         function createSemicolonClassElement() {
             var node = createBaseNode(233 /* SemicolonClassElement */);
-            node.transformFlags |= 512 /* ContainsES2015 */;
+            node.transformFlags |= 1024 /* ContainsES2015 */;
             return node;
         }
         //
@@ -24193,9 +24217,9 @@ var ts;
                     propagateChildFlags(node.initializer) |
                     propagateChildFlags(node.expression) |
                     propagateChildFlags(node.statement) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             if (awaitModifier)
-                node.transformFlags |= 64 /* ContainsES2018 */;
+                node.transformFlags |= 128 /* ContainsES2018 */;
             return node;
         }
         // @api
@@ -24244,7 +24268,7 @@ var ts;
             // return in an ES2018 async generator must be awaited
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
-                    64 /* ContainsES2018 */ |
+                    128 /* ContainsES2018 */ |
                     2097152 /* ContainsHoistedDeclarationOrCompletion */;
             return node;
         }
@@ -24374,7 +24398,7 @@ var ts;
                     2097152 /* ContainsHoistedDeclarationOrCompletion */;
             if (flags & 3 /* BlockScoped */) {
                 node.transformFlags |=
-                    512 /* ContainsES2015 */ |
+                    1024 /* ContainsES2015 */ |
                         131072 /* ContainsBlockScopedBinding */;
             }
             return node;
@@ -24398,14 +24422,14 @@ var ts;
                         2097152 /* ContainsHoistedDeclarationOrCompletion */;
                 if (ts.modifiersToFlags(node.modifiers) & 256 /* Async */) {
                     if (node.asteriskToken) {
-                        node.transformFlags |= 64 /* ContainsES2018 */;
+                        node.transformFlags |= 128 /* ContainsES2018 */;
                     }
                     else {
-                        node.transformFlags |= 128 /* ContainsES2017 */;
+                        node.transformFlags |= 256 /* ContainsES2017 */;
                     }
                 }
                 else if (node.asteriskToken) {
-                    node.transformFlags |= 1024 /* ContainsGenerator */;
+                    node.transformFlags |= 2048 /* ContainsGenerator */;
                 }
             }
             return node;
@@ -24430,7 +24454,7 @@ var ts;
                 node.transformFlags = 1 /* ContainsTypeScript */;
             }
             else {
-                node.transformFlags |= 512 /* ContainsES2015 */;
+                node.transformFlags |= 1024 /* ContainsES2015 */;
                 if (node.transformFlags & 4096 /* ContainsTypeScriptClassSyntax */) {
                     node.transformFlags |= 1 /* ContainsTypeScript */;
                 }
@@ -25470,7 +25494,7 @@ var ts;
             node.transformFlags |= propagateChildrenFlags(node.types);
             switch (token) {
                 case 94 /* ExtendsKeyword */:
-                    node.transformFlags |= 512 /* ContainsES2015 */;
+                    node.transformFlags |= 1024 /* ContainsES2015 */;
                     break;
                 case 117 /* ImplementsKeyword */:
                     node.transformFlags |= 1 /* ContainsTypeScript */;
@@ -25501,7 +25525,7 @@ var ts;
                 propagateChildFlags(node.variableDeclaration) |
                     propagateChildFlags(node.block);
             if (!variableDeclaration)
-                node.transformFlags |= 32 /* ContainsES2019 */;
+                node.transformFlags |= 64 /* ContainsES2019 */;
             return node;
         }
         // @api
@@ -25552,7 +25576,7 @@ var ts;
             node.objectAssignmentInitializer = objectAssignmentInitializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(objectAssignmentInitializer);
             node.transformFlags |=
                 propagateChildFlags(node.objectAssignmentInitializer) |
-                    512 /* ContainsES2015 */;
+                    1024 /* ContainsES2015 */;
             return node;
         }
         function finishUpdateShorthandPropertyAssignment(updated, original) {
@@ -25582,7 +25606,7 @@ var ts;
             node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
-                    64 /* ContainsES2018 */ |
+                    128 /* ContainsES2018 */ |
                     32768 /* ContainsObjectRestOrSpread */;
             return node;
         }
@@ -38255,6 +38279,7 @@ var ts;
         ["es2019", "lib.es2019.d.ts"],
         ["es2020", "lib.es2020.d.ts"],
         ["es2021", "lib.es2021.d.ts"],
+        ["es2022", "lib.es2022.d.ts"],
         ["esnext", "lib.esnext.d.ts"],
         // Host only
         ["dom", "lib.dom.d.ts"],
@@ -38298,12 +38323,16 @@ var ts;
         ["es2021.string", "lib.es2021.string.d.ts"],
         ["es2021.weakref", "lib.es2021.weakref.d.ts"],
         ["es2021.intl", "lib.es2021.intl.d.ts"],
-        ["esnext.array", "lib.es2019.array.d.ts"],
+        ["es2022.array", "lib.es2022.array.d.ts"],
+        ["es2022.error", "lib.es2022.error.d.ts"],
+        ["es2022.object", "lib.es2022.object.d.ts"],
+        ["es2022.string", "lib.es2022.string.d.ts"],
+        ["esnext.array", "lib.es2022.array.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
         ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["esnext.intl", "lib.esnext.intl.d.ts"],
         ["esnext.bigint", "lib.es2020.bigint.d.ts"],
-        ["esnext.string", "lib.es2021.string.d.ts"],
+        ["esnext.string", "lib.es2022.string.d.ts"],
         ["esnext.promise", "lib.es2021.promise.d.ts"],
         ["esnext.weakref", "lib.es2021.weakref.d.ts"]
     ];
@@ -38535,6 +38564,7 @@ var ts;
             es2019: 6 /* ES2019 */,
             es2020: 7 /* ES2020 */,
             es2021: 8 /* ES2021 */,
+            es2022: 9 /* ES2022 */,
             esnext: 99 /* ESNext */,
         })),
         affectsSourceFile: true,
@@ -54312,12 +54342,15 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var pattern = declaration.parent;
-            var parentType = getTypeForBindingElementParent(pattern.parent);
-            // If no type or an any type was inferred for parent, infer that for the binding element
-            if (!parentType || isTypeAny(parentType)) {
+            var parentType = getTypeForBindingElementParent(declaration.parent.parent);
+            return parentType && getBindingElementTypeFromParentType(declaration, parentType);
+        }
+        function getBindingElementTypeFromParentType(declaration, parentType) {
+            // If an any type was inferred for parent, infer that for the binding element
+            if (isTypeAny(parentType)) {
                 return parentType;
             }
+            var pattern = declaration.parent;
             // Relax null check on ambient destructuring parameters, since the parameters have no implementation and are just documentation
             if (strictNullChecks && declaration.flags & 8388608 /* Ambient */ && ts.isParameterDeclaration(declaration)) {
                 parentType = getNonNullableType(parentType);
@@ -59529,6 +59562,8 @@ var ts;
             // We ignore 'never' types in unions
             if (!(flags & 131072 /* Never */)) {
                 includes |= flags & 205258751 /* IncludesMask */;
+                if (flags & 465829888 /* Instantiable */)
+                    includes |= 33554432 /* IncludesInstantiable */;
                 if (type === wildcardType)
                     includes |= 8388608 /* IncludesWildcard */;
                 if (!strictNullChecks && flags & 98304 /* Nullable */) {
@@ -59742,7 +59777,7 @@ var ts;
                     origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
                 }
             }
-            var objectFlags = (includes & 468598819 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) |
+            var objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) |
                 (includes & 2097152 /* Intersection */ ? 33554432 /* ContainsIntersections */ : 0);
             return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
         }
@@ -61292,7 +61327,7 @@ var ts;
                         var declarations = ts.concatenate(leftProp.declarations, rightProp.declarations);
                         var flags = 4 /* Property */ | (leftProp.flags & 16777216 /* Optional */);
                         var result = createSymbol(flags, leftProp.escapedName);
-                        result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)]);
+                        result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], 2 /* Subtype */);
                         result.leftSpread = leftProp;
                         result.rightSpread = rightProp;
                         result.declarations = declarations;
@@ -62937,7 +62972,7 @@ var ts;
                     return true;
             }
             if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
-                var related = relation.get(getRelationKey(source, target, 0 /* None */, relation));
+                var related = relation.get(getRelationKey(source, target, 0 /* None */, relation, /*ignoreConstraints*/ false));
                 if (related !== undefined) {
                     return !!(related & 1 /* Succeeded */);
                 }
@@ -63786,7 +63821,8 @@ var ts;
                 if (overflow) {
                     return 0 /* False */;
                 }
-                var id = getRelationKey(source, target, intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0), relation);
+                var keyIntersectionState = intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0);
+                var id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
                     if (reportErrors && entry & 2 /* Failed */ && !(entry & 4 /* Reported */)) {
@@ -63813,16 +63849,13 @@ var ts;
                     targetStack = [];
                 }
                 else {
-                    // generate a key where all type parameter id positions are replaced with unconstrained type parameter ids
-                    // this isn't perfect - nested type references passed as type arguments will muck up the indexes and thus
-                    // prevent finding matches- but it should hit up the common cases
-                    var broadestEquivalentId = id.split(",").map(function (i) { return i.replace(/-\d+/g, function (_match, offset) {
-                        var index = ts.length(id.slice(0, offset).match(/[-=]/g) || undefined);
-                        return "=" + index;
-                    }); }).join(",");
+                    // A key that starts with "*" is an indication that we have type references that reference constrained
+                    // type parameters. For such keys we also check against the key we would have gotten if all type parameters
+                    // were unconstrained.
+                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, /*ignoreConstraints*/ true) : undefined;
                     for (var i = 0; i < maybeCount; i++) {
                         // If source and target are already being compared, consider them related with assumptions
-                        if (id === maybeKeys[i] || broadestEquivalentId === maybeKeys[i]) {
+                        if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
                             return 3 /* Maybe */;
                         }
                     }
@@ -64117,7 +64150,7 @@ var ts;
                         originalErrorInfo = undefined;
                     }
                 }
-                else if (isGenericMappedType(target)) {
+                else if (isGenericMappedType(target) && relation !== identityRelation) {
                     // Check if source type `S` is related to target type `{ [P in Q]: T }` or `{ [P in Q as R]: T}`.
                     var keysRemapped = !!target.declaration.nameType;
                     var templateType = getTemplateTypeFromMappedType(target);
@@ -65329,48 +65362,56 @@ var ts;
         function isTypeReferenceWithGenericArguments(type) {
             return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return !!(t.flags & 262144 /* TypeParameter */) || isTypeReferenceWithGenericArguments(t); });
         }
-        /**
-         * getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
-         *   where A.id=111 and number.id=12
-         */
-        function getTypeReferenceId(type, typeParameters, depth) {
-            if (depth === void 0) { depth = 0; }
-            var result = "" + type.target.id;
-            for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
-                var t = _a[_i];
-                if (isUnconstrainedTypeParameter(t)) {
-                    var index = typeParameters.indexOf(t);
-                    if (index < 0) {
-                        index = typeParameters.length;
-                        typeParameters.push(t);
+        function getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) {
+            var typeParameters = [];
+            var constraintMarker = "";
+            var sourceId = getTypeReferenceId(source, 0);
+            var targetId = getTypeReferenceId(target, 0);
+            return "" + constraintMarker + sourceId + "," + targetId + postFix;
+            // getTypeReferenceId(A<T, number, U>) returns "111=0-12=1"
+            // where A.id=111 and number.id=12
+            function getTypeReferenceId(type, depth) {
+                if (depth === void 0) { depth = 0; }
+                var result = "" + type.target.id;
+                for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) {
+                    var t = _a[_i];
+                    if (t.flags & 262144 /* TypeParameter */) {
+                        if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
+                            var index = typeParameters.indexOf(t);
+                            if (index < 0) {
+                                index = typeParameters.length;
+                                typeParameters.push(t);
+                            }
+                            result += "=" + index;
+                            continue;
+                        }
+                        // We mark type references that reference constrained type parameters such that we know to obtain
+                        // and look for a "broadest equivalent key" in the cache.
+                        constraintMarker = "*";
+                    }
+                    else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
+                        result += "<" + getTypeReferenceId(t, depth + 1) + ">";
+                        continue;
                     }
-                    result += "=" + index;
-                }
-                else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
-                    result += "<" + getTypeReferenceId(t, typeParameters, depth + 1) + ">";
-                }
-                else {
                     result += "-" + t.id;
                 }
+                return result;
             }
-            return result;
         }
         /**
          * To improve caching, the relation key for two generic types uses the target's id plus ids of the type parameters.
          * For other cases, the types ids are used.
          */
-        function getRelationKey(source, target, intersectionState, relation) {
+        function getRelationKey(source, target, intersectionState, relation, ignoreConstraints) {
             if (relation === identityRelation && source.id > target.id) {
                 var temp = source;
                 source = target;
                 target = temp;
             }
             var postFix = intersectionState ? ":" + intersectionState : "";
-            if (isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target)) {
-                var typeParameters = [];
-                return getTypeReferenceId(source, typeParameters) + "," + getTypeReferenceId(target, typeParameters) + postFix;
-            }
-            return source.id + "," + target.id + postFix;
+            return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ?
+                getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) :
+                source.id + "," + target.id + postFix;
         }
         // Invoke the callback for each underlying property symbol of the given symbol and return the first
         // value that isn't undefined.
@@ -65418,28 +65459,35 @@ var ts;
                 !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass;
         }
         // Return true if the given type is deeply nested. We consider this to be the case when structural type comparisons
-        // for 5 or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,
+        // for maxDepth or more occurrences or instantiations of the type have been recorded on the given stack. It is possible,
         // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely
-        // expanding. Effectively, we will generate a false positive when two types are structurally equal to at least 5
+        // expanding. Effectively, we will generate a false positive when two types are structurally equal to at least maxDepth
         // levels, but unequal at some level beyond that.
-        // In addition, this will also detect when an indexed access has been chained off of 5 or more times (which is essentially
-        // the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding false positives
-        // for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`).
-        // It also detects when a recursive type reference has expanded 5 or more times, eg, if the true branch of
+        // In addition, this will also detect when an indexed access has been chained off of maxDepth more times (which is
+        // essentially the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding
+        // false positives for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`).
+        // It also detects when a recursive type reference has expanded maxDepth or more times, e.g. if the true branch of
         // `type A<T> = null extends T ? [A<NonNullable<T>>] : [T]`
-        // has expanded into `[A<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>>>>>>]`
-        // in such cases we need to terminate the expansion, and we do so here.
+        // has expanded into `[A<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T>>>>>>]`. In such cases we need
+        // to terminate the expansion, and we do so here.
         function isDeeplyNestedType(type, stack, depth, maxDepth) {
-            if (maxDepth === void 0) { maxDepth = 5; }
+            if (maxDepth === void 0) { maxDepth = 3; }
             if (depth >= maxDepth) {
                 var identity_1 = getRecursionIdentity(type);
                 var count = 0;
+                var lastTypeId = 0;
                 for (var i = 0; i < depth; i++) {
-                    if (getRecursionIdentity(stack[i]) === identity_1) {
-                        count++;
-                        if (count >= maxDepth) {
-                            return true;
+                    var t = stack[i];
+                    if (getRecursionIdentity(t) === identity_1) {
+                        // We only count occurrences with a higher type id than the previous occurrence, since higher
+                        // type ids are an indicator of newer instantiations caused by recursion.
+                        if (t.id >= lastTypeId) {
+                            count++;
+                            if (count >= maxDepth) {
+                                return true;
+                            }
                         }
+                        lastTypeId = t.id;
                     }
                 }
             }
@@ -66178,7 +66226,8 @@ var ts;
                         (resolveName(param, param.name.escapedText, 788968 /* Type */, undefined, param.name.escapedText, /*isUse*/ true) ||
                             param.name.originalKeywordKind && ts.isTypeNodeKind(param.name.originalKeywordKind))) {
                         var newName = "arg" + param.parent.parameters.indexOf(param);
-                        errorOrSuggestion(noImplicitAny, declaration, ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, ts.declarationNameToString(param.name));
+                        var typeName = ts.declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : "");
+                        errorOrSuggestion(noImplicitAny, declaration, ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName);
                         return;
                     }
                     diagnostic = declaration.dotDotDotToken ?
@@ -67544,29 +67593,6 @@ var ts;
             }
             return false;
         }
-        function getPropertyAccess(expr) {
-            if (ts.isAccessExpression(expr)) {
-                return expr;
-            }
-            if (ts.isIdentifier(expr)) {
-                var symbol = getResolvedSymbol(expr);
-                if (isConstVariable(symbol)) {
-                    var declaration = symbol.valueDeclaration;
-                    // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
-                    if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.isAccessExpression(declaration.initializer)) {
-                        return declaration.initializer;
-                    }
-                    // Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
-                    if (ts.isBindingElement(declaration) && !declaration.initializer) {
-                        var parent = declaration.parent.parent;
-                        if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer))) {
-                            return declaration;
-                        }
-                    }
-                }
-            }
-            return undefined;
-        }
         function getAccessedPropertyName(access) {
             var propertyName;
             return access.kind === 205 /* PropertyAccessExpression */ ? access.name.escapedText :
@@ -68465,20 +68491,21 @@ var ts;
             }
             return false;
         }
-        function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer) {
+        function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, flowNode) {
             if (initialType === void 0) { initialType = declaredType; }
+            if (flowNode === void 0) { flowNode = reference.flowNode; }
             var key;
             var isKeySet = false;
             var flowDepth = 0;
             if (flowAnalysisDisabled) {
                 return errorType;
             }
-            if (!reference.flowNode) {
+            if (!flowNode) {
                 return declaredType;
             }
             flowInvocationCount++;
             var sharedFlowStart = sharedFlowCount;
-            var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(reference.flowNode));
+            var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
             sharedFlowCount = sharedFlowStart;
             // When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation,
             // we give type 'any[]' to 'x' instead of using the type determined by control flow analysis such that operations
@@ -68910,13 +68937,57 @@ var ts;
                 }
                 return result;
             }
+            function getCandidateDiscriminantPropertyAccess(expr) {
+                if (ts.isBindingPattern(reference)) {
+                    // When the reference is a binding pattern, we are narrowing a pesudo-reference in getNarrowedTypeOfSymbol.
+                    // An identifier for a destructuring variable declared in the same binding pattern is a candidate.
+                    if (ts.isIdentifier(expr)) {
+                        var symbol = getResolvedSymbol(expr);
+                        var declaration = symbol.valueDeclaration;
+                        if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
+                            return declaration;
+                        }
+                    }
+                }
+                else if (ts.isAccessExpression(expr)) {
+                    // An access expression is a candidate if the reference matches the left hand expression.
+                    if (isMatchingReference(reference, expr.expression)) {
+                        return expr;
+                    }
+                }
+                else if (ts.isIdentifier(expr)) {
+                    var symbol = getResolvedSymbol(expr);
+                    if (isConstVariable(symbol)) {
+                        var declaration = symbol.valueDeclaration;
+                        // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind'
+                        if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.isAccessExpression(declaration.initializer) &&
+                            isMatchingReference(reference, declaration.initializer.expression)) {
+                            return declaration.initializer;
+                        }
+                        // Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind'
+                        if (ts.isBindingElement(declaration) && !declaration.initializer) {
+                            var parent = declaration.parent.parent;
+                            if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer)) &&
+                                isMatchingReference(reference, parent.initializer)) {
+                                return declaration;
+                            }
+                        }
+                    }
+                }
+                return undefined;
+            }
             function getDiscriminantPropertyAccess(expr, computedType) {
-                var access, name;
                 var type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
-                return type.flags & 1048576 /* Union */ && (access = getPropertyAccess(expr)) && (name = getAccessedPropertyName(access)) &&
-                    isMatchingReference(reference, ts.isAccessExpression(access) ? access.expression : access.parent.parent.initializer) &&
-                    isDiscriminantProperty(type, name) ?
-                    access : undefined;
+                if (type.flags & 1048576 /* Union */) {
+                    var access = getCandidateDiscriminantPropertyAccess(expr);
+                    if (access) {
+                        var name = getAccessedPropertyName(access);
+                        if (name && isDiscriminantProperty(type, name)) {
+                            return access;
+                        }
+                    }
+                }
+                return undefined;
             }
             function narrowTypeByDiscriminant(type, access, narrowType) {
                 var propName = getAccessedPropertyName(access);
@@ -69674,6 +69745,49 @@ var ts;
                 }
             }
         }
+        function getNarrowedTypeOfSymbol(symbol, location) {
+            // If we have a non-rest binding element with no initializer declared as a const variable or a const-like
+            // parameter (a parameter for which there are no assignments in the function body), and if the parent type
+            // for the destructuring is a union type, one or more of the binding elements may represent discriminant
+            // properties, and we want the effects of conditional checks on such discriminants to affect the types of
+            // other binding elements from the same destructuring. Consider:
+            //
+            //   type Action =
+            //       | { kind: 'A', payload: number }
+            //       | { kind: 'B', payload: string };
+            //
+            //   function f1({ kind, payload }: Action) {
+            //       if (kind === 'A') {
+            //           payload.toFixed();
+            //       }
+            //       if (kind === 'B') {
+            //           payload.toUpperCase();
+            //       }
+            //   }
+            //
+            // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
+            // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
+            // as if it occurred in the specified location. We then recompute the narrowed binding element type by
+            // destructuring from the narrowed parent type.
+            var declaration = symbol.valueDeclaration;
+            if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
+                var parent = declaration.parent.parent;
+                if (parent.kind === 253 /* VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 163 /* Parameter */) {
+                    var links = getNodeLinks(location);
+                    if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
+                        links.flags |= 268435456 /* InCheckIdentifier */;
+                        var parentType = getTypeForBindingElementParent(parent);
+                        links.flags &= ~268435456 /* InCheckIdentifier */;
+                        if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
+                            var pattern = declaration.parent;
+                            var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
+                            return getBindingElementTypeFromParentType(declaration, narrowedType);
+                        }
+                    }
+                }
+            }
+            return getTypeOfSymbol(symbol);
+        }
         function checkIdentifier(node, checkMode) {
             var symbol = getResolvedSymbol(node);
             if (symbol === unknownSymbol) {
@@ -69747,7 +69861,7 @@ var ts;
                 }
             }
             checkNestedBlockScopedBinding(node, symbol);
-            var type = getTypeOfSymbol(localOrExportSymbol);
+            var type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
             var assignmentKind = ts.getAssignmentTargetKind(node);
             if (assignmentKind) {
                 if (!(localOrExportSymbol.flags & 3 /* Variable */) &&
@@ -70790,13 +70904,13 @@ var ts;
         function isCircularMappedProperty(symbol) {
             return !!(ts.getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0);
         }
-        function getTypeOfPropertyOfContextualType(type, name) {
+        function getTypeOfPropertyOfContextualType(type, name, nameType) {
             return mapType(type, function (t) {
                 var _a;
                 if (isGenericMappedType(t)) {
                     var constraint = getConstraintTypeFromMappedType(t);
                     var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-                    var propertyNameType = getStringLiteralType(ts.unescapeLeadingUnderscores(name));
+                    var propertyNameType = nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name));
                     if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
                         return substituteIndexedMappedType(t, propertyNameType);
                     }
@@ -70812,7 +70926,7 @@ var ts;
                             return restType;
                         }
                     }
-                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
+                    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type;
                 }
                 return undefined;
             }, /*noReductions*/ true);
@@ -70840,7 +70954,8 @@ var ts;
                     // For a (non-symbol) computed property, there is no reason to look up the name
                     // in the type. It will just be "__computed", which does not appear in any
                     // SymbolTable.
-                    return getTypeOfPropertyOfContextualType(type, getSymbolOfNode(element).escapedName);
+                    var symbol = getSymbolOfNode(element);
+                    return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
                 }
                 if (element.name) {
                     var nameType_2 = getLiteralTypeFromPropertyName(element.name);
@@ -82963,8 +83078,11 @@ var ts;
         function checkAssertClause(declaration) {
             var _a;
             if (declaration.assertClause) {
-                if (moduleKind !== ts.ModuleKind.ESNext) {
-                    return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext);
+                var mode = (moduleKind === ts.ModuleKind.NodeNext) && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
+                if (mode !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.ESNext) {
+                    return grammarErrorOnNode(declaration.assertClause, moduleKind === ts.ModuleKind.NodeNext
+                        ? ts.Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls
+                        : ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
                 if (ts.isImportDeclaration(declaration) ? (_a = declaration.importClause) === null || _a === void 0 ? void 0 : _a.isTypeOnly : declaration.isTypeOnly) {
                     return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports);
@@ -86811,12 +86929,12 @@ var ts;
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
             }
             var nodeArguments = node.arguments;
-            if (moduleKind !== ts.ModuleKind.ESNext) {
+            if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext) {
                 // We are allowed trailing comma after proposal-import-assertions.
                 checkGrammarForDisallowedTrailingComma(nodeArguments);
                 if (nodeArguments.length > 1) {
                     var assertionArgument = nodeArguments[1];
-                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext);
+                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext);
                 }
             }
             if (nodeArguments.length === 0 || nodeArguments.length > 2) {
@@ -93516,7 +93634,7 @@ var ts;
             return ts.visitEachChild(node, visitor, context);
         }
         function visitor(node) {
-            if ((node.transformFlags & 128 /* ContainsES2017 */) === 0) {
+            if ((node.transformFlags & 256 /* ContainsES2017 */) === 0) {
                 return node;
             }
             switch (node.kind) {
@@ -94149,7 +94267,7 @@ var ts;
          * expression of an `ExpressionStatement`).
          */
         function visitorWorker(node, expressionResultIsUnused) {
-            if ((node.transformFlags & 64 /* ContainsES2018 */) === 0) {
+            if ((node.transformFlags & 128 /* ContainsES2018 */) === 0) {
                 return node;
             }
             switch (node.kind) {
@@ -94846,7 +94964,7 @@ var ts;
             return ts.visitEachChild(node, visitor, context);
         }
         function visitor(node) {
-            if ((node.transformFlags & 32 /* ContainsES2019 */) === 0) {
+            if ((node.transformFlags & 64 /* ContainsES2019 */) === 0) {
                 return node;
             }
             switch (node.kind) {
@@ -94878,7 +94996,7 @@ var ts;
             return ts.visitEachChild(node, visitor, context);
         }
         function visitor(node) {
-            if ((node.transformFlags & 16 /* ContainsES2020 */) === 0) {
+            if ((node.transformFlags & 32 /* ContainsES2020 */) === 0) {
                 return node;
             }
             switch (node.kind) {
@@ -95055,7 +95173,7 @@ var ts;
             return ts.visitEachChild(node, visitor, context);
         }
         function visitor(node) {
-            if ((node.transformFlags & 8 /* ContainsES2021 */) === 0) {
+            if ((node.transformFlags & 16 /* ContainsES2021 */) === 0) {
                 return node;
             }
             switch (node.kind) {
@@ -95819,7 +95937,7 @@ var ts;
             return ts.visitEachChild(node, visitor, context);
         }
         function visitor(node) {
-            if ((node.transformFlags & 256 /* ContainsES2016 */) === 0) {
+            if ((node.transformFlags & 512 /* ContainsES2016 */) === 0) {
                 return node;
             }
             switch (node.kind) {
@@ -96067,7 +96185,7 @@ var ts;
                     || ts.isBlock(node));
         }
         function shouldVisitNode(node) {
-            return (node.transformFlags & 512 /* ContainsES2015 */) !== 0
+            return (node.transformFlags & 1024 /* ContainsES2015 */) !== 0
                 || convertedLoopState !== undefined
                 || (hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */ && isOrMayContainReturnCompletion(node))
                 || (ts.isIterationStatement(node, /*lookInLabeledStatements*/ false) && shouldConvertIterationStatement(node))
@@ -99380,7 +99498,7 @@ var ts;
         var withBlockStack; // A stack containing `with` blocks.
         return ts.chainBundle(context, transformSourceFile);
         function transformSourceFile(node) {
-            if (node.isDeclarationFile || (node.transformFlags & 1024 /* ContainsGenerator */) === 0) {
+            if (node.isDeclarationFile || (node.transformFlags & 2048 /* ContainsGenerator */) === 0) {
                 return node;
             }
             var visited = ts.visitEachChild(node, visitor, context);
@@ -99403,7 +99521,7 @@ var ts;
             else if (ts.isFunctionLikeDeclaration(node) && node.asteriskToken) {
                 return visitGenerator(node);
             }
-            else if (transformFlags & 1024 /* ContainsGenerator */) {
+            else if (transformFlags & 2048 /* ContainsGenerator */) {
                 return ts.visitEachChild(node, visitor, context);
             }
             else {
@@ -99459,7 +99577,7 @@ var ts;
                     if (node.transformFlags & 524288 /* ContainsYield */) {
                         return visitJavaScriptContainingYield(node);
                     }
-                    else if (node.transformFlags & (1024 /* ContainsGenerator */ | 2097152 /* ContainsHoistedDeclarationOrCompletion */)) {
+                    else if (node.transformFlags & (2048 /* ContainsGenerator */ | 2097152 /* ContainsHoistedDeclarationOrCompletion */)) {
                         return ts.visitEachChild(node, visitor, context);
                     }
                     else {
@@ -102108,7 +102226,7 @@ var ts;
         function visitorWorker(node, valueIsDiscarded) {
             // This visitor does not need to descend into the tree if there is no dynamic import, destructuring assignment, or update expression
             // as export/import statements are only transformed at the top level of a file.
-            if (!(node.transformFlags & (4194304 /* ContainsDynamicImport */ | 2048 /* ContainsDestructuringAssignment */ | 67108864 /* ContainsUpdateExpressionForIdentifier */))) {
+            if (!(node.transformFlags & (4194304 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 67108864 /* ContainsUpdateExpressionForIdentifier */))) {
                 return node;
             }
             switch (node.kind) {
@@ -104324,7 +104442,7 @@ var ts;
          * @param node The node to visit.
          */
         function visitorWorker(node, valueIsDiscarded) {
-            if (!(node.transformFlags & (2048 /* ContainsDestructuringAssignment */ | 4194304 /* ContainsDynamicImport */ | 67108864 /* ContainsUpdateExpressionForIdentifier */))) {
+            if (!(node.transformFlags & (4096 /* ContainsDestructuringAssignment */ | 4194304 /* ContainsDynamicImport */ | 67108864 /* ContainsUpdateExpressionForIdentifier */))) {
                 return node;
             }
             switch (node.kind) {
@@ -119549,13 +119667,15 @@ var ts;
                 if (host.fileExists(packageJsonPath)) {
                     var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
                     // TODO: Inject `require` or `import` condition based on the intended import mode
-                    var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
-                    if (fromExports) {
-                        var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
-                        return __assign(__assign({}, withJsExtension), { verbatimFromExports: true });
-                    }
-                    if (packageJsonContent.exports) {
-                        return { moduleFileToTry: path, blockedByExports: true };
+                    if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
+                        var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
+                        if (fromExports) {
+                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
+                            return __assign(__assign({}, withJsExtension), { verbatimFromExports: true });
+                        }
+                        if (packageJsonContent.exports) {
+                            return { moduleFileToTry: path, blockedByExports: true };
+                        }
                     }
                     var versionPaths = packageJsonContent.typesVersions
                         ? ts.getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)
@@ -129331,7 +129451,7 @@ var ts;
                 }
                 node = ts.factory.updateModifiers(node, modifiers & (~presentModifiers));
                 completionNodes.push(node);
-            }, body, isAbstract);
+            }, body, 2 /* Property */, isAbstract);
             if (completionNodes.length) {
                 insertText = printer.printSnippetList(1 /* MultiLine */, ts.factory.createNodeArray(completionNodes), sourceFile);
             }
@@ -138172,7 +138292,7 @@ var ts;
                 if (depthRemaining === 0)
                     return;
                 cancellationToken.throwIfCancellationRequested();
-                if (ts.isDeclaration(n) || ts.isVariableStatement(n) || ts.isReturnStatement(n) || n.kind === 1 /* EndOfFileToken */) {
+                if (ts.isDeclaration(n) || ts.isVariableStatement(n) || ts.isReturnStatement(n) || ts.isCallOrNewExpression(n) || n.kind === 1 /* EndOfFileToken */) {
                     addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out);
                 }
                 if (ts.isFunctionLike(n) && ts.isBinaryExpression(n.parent) && ts.isPropertyAccessExpression(n.parent.left)) {
@@ -146698,9 +146818,6 @@ var ts;
         });
         function makeChange(changeTracker, sourceFile, pos) {
             var token = ts.getTokenAtPosition(sourceFile, pos);
-            if (!ts.isIdentifier(token)) {
-                return ts.Debug.fail("add-name-to-nameless-parameter operates on identifiers, but got a " + ts.Debug.formatSyntaxKind(token.kind));
-            }
             var param = token.parent;
             if (!ts.isParameter(param)) {
                 return ts.Debug.fail("Tried to add a parameter name to a non-parameter: " + ts.Debug.formatSyntaxKind(token.kind));
@@ -146708,9 +146825,10 @@ var ts;
             var i = param.parent.parameters.indexOf(param);
             ts.Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one.");
             ts.Debug.assert(i > -1, "Parameter not found in parent parameter list.");
+            var typeNode = ts.factory.createTypeReferenceNode(param.name, /*typeArguments*/ undefined);
             var replacement = ts.factory.createParameterDeclaration(
-            /*decorators*/ undefined, param.modifiers, param.dotDotDotToken, "arg" + i, param.questionToken, ts.factory.createTypeReferenceNode(token, /*typeArguments*/ undefined), param.initializer);
-            changeTracker.replaceNode(sourceFile, token, replacement);
+            /*decorators*/ undefined, param.modifiers, param.dotDotDotToken, "arg" + i, param.questionToken, param.dotDotDotToken ? ts.factory.createArrayTypeNode(typeNode) : typeNode, param.initializer);
+            changeTracker.replaceNode(sourceFile, param, replacement);
         }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
@@ -152879,10 +152997,22 @@ var ts;
                 if (usage.numberIndex) {
                     types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
                 }
-                if (((_a = usage.properties) === null || _a === void 0 ? void 0 : _a.size) || ((_b = usage.calls) === null || _b === void 0 ? void 0 : _b.length) || ((_c = usage.constructs) === null || _c === void 0 ? void 0 : _c.length) || usage.stringIndex) {
+                if (((_a = usage.properties) === null || _a === void 0 ? void 0 : _a.size) || ((_b = usage.constructs) === null || _b === void 0 ? void 0 : _b.length) || usage.stringIndex) {
                     types.push(inferStructuralType(usage));
                 }
-                types.push.apply(types, (usage.candidateTypes || []).map(function (t) { return checker.getBaseTypeOfLiteralType(t); }));
+                var candidateTypes = (usage.candidateTypes || []).map(function (t) { return checker.getBaseTypeOfLiteralType(t); });
+                var callsType = ((_c = usage.calls) === null || _c === void 0 ? void 0 : _c.length) ? inferStructuralType(usage) : undefined;
+                if (callsType && candidateTypes) {
+                    types.push(checker.getUnionType(__spreadArray([callsType], candidateTypes, true), 2 /* Subtype */));
+                }
+                else {
+                    if (callsType) {
+                        types.push(callsType);
+                    }
+                    if (ts.length(candidateTypes)) {
+                        types.push.apply(types, candidateTypes);
+                    }
+                }
                 types.push.apply(types, inferNamedTypesFromProperties(usage));
                 return types;
             }
@@ -153164,11 +153294,18 @@ var ts;
             };
         }
         codefix.getNoopSymbolTrackerWithResolver = getNoopSymbolTrackerWithResolver;
+        var PreserveOptionalFlags;
+        (function (PreserveOptionalFlags) {
+            PreserveOptionalFlags[PreserveOptionalFlags["Method"] = 1] = "Method";
+            PreserveOptionalFlags[PreserveOptionalFlags["Property"] = 2] = "Property";
+            PreserveOptionalFlags[PreserveOptionalFlags["All"] = 3] = "All";
+        })(PreserveOptionalFlags = codefix.PreserveOptionalFlags || (codefix.PreserveOptionalFlags = {}));
         /**
          * `addClassElement` will not be called if we can't figure out a representation for `symbol` in `enclosingDeclaration`.
          * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
          */
-        function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, isAmbient) {
+        function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional, isAmbient) {
+            if (preserveOptional === void 0) { preserveOptional = 3 /* All */; }
             if (isAmbient === void 0) { isAmbient = false; }
             var declarations = symbol.getDeclarations();
             if (!(declarations && declarations.length)) {
@@ -153197,7 +153334,7 @@ var ts;
                         }
                     }
                     addClassElement(ts.factory.createPropertyDeclaration(
-                    /*decorators*/ undefined, modifiers, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeNode, 
+                    /*decorators*/ undefined, modifiers, name, optional && (preserveOptional & 2 /* Property */) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeNode, 
                     /*initializer*/ undefined));
                     break;
                 case 171 /* GetAccessor */:
@@ -153261,13 +153398,13 @@ var ts;
                         }
                         else {
                             ts.Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
-                            addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body));
+                            addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional && !!(preserveOptional & 1 /* Method */), modifiers, quotePreference, body));
                         }
                     }
                     break;
             }
             function outputMethod(quotePreference, signature, modifiers, name, body) {
-                var method = createSignatureDeclarationFromSignature(168 /* MethodDeclaration */, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder);
+                var method = createSignatureDeclarationFromSignature(168 /* MethodDeclaration */, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & 1 /* Method */), enclosingDeclaration, importAdder);
                 if (method)
                     addClassElement(method);
             }
@@ -155706,11 +155843,12 @@ var ts;
                             return node.expression;
                         }
                     }
-                    else if (ts.isVariableStatement(node)) {
+                    else if (ts.isVariableStatement(node) || ts.isVariableDeclarationList(node)) {
+                        var declarations_5 = ts.isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
                         var numInitializers = 0;
                         var lastInitializer = void 0;
-                        for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
-                            var declaration = _a[_i];
+                        for (var _i = 0, declarations_4 = declarations_5; _i < declarations_4.length; _i++) {
+                            var declaration = declarations_4[_i];
                             if (declaration.initializer) {
                                 numInitializers++;
                                 lastInitializer = declaration.initializer;
@@ -159780,8 +159918,8 @@ var ts;
         var doc = ts.JsDoc.getJsDocCommentsFromDeclarations(declarations, checker);
         if (checker && (doc.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
             var seenSymbols_1 = new ts.Set();
-            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
-                var declaration = declarations_4[_i];
+            for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                var declaration = declarations_6[_i];
                 var inheritedDocs = findBaseOfDeclaration(checker, declaration, function (symbol) {
                     if (!seenSymbols_1.has(symbol)) {
                         seenSymbols_1.add(symbol);