@typescript-deploys/pr-build 4.9.0-pr-50820-12 → 5.0.0-pr-50820-19

package/lib/tsc.js

@@ -68,8 +68,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 var ts;
 (function (ts) {
-    ts.versionMajorMinor = "4.9";
-    ts.version = "".concat(ts.versionMajorMinor, ".0-insiders.20221027");
+    ts.versionMajorMinor = "5.0";
+    ts.version = "".concat(ts.versionMajorMinor, ".0-insiders.20221101");
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -5656,6 +5656,8 @@ var ts;
         _0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias: diag(1274, ts.DiagnosticCategory.Error, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias_1274", "'{0}' modifier can only appear on a type parameter of a class, interface or type alias"),
         accessor_modifier_can_only_appear_on_a_property_declaration: diag(1275, ts.DiagnosticCategory.Error, "accessor_modifier_can_only_appear_on_a_property_declaration_1275", "'accessor' modifier can only appear on a property declaration."),
         An_accessor_property_cannot_be_declared_optional: diag(1276, ts.DiagnosticCategory.Error, "An_accessor_property_cannot_be_declared_optional_1276", "An 'accessor' property cannot be declared optional."),
+        The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0: diag(1277, ts.DiagnosticCategory.Error, "The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0_1277", "The runtime will invoke the decorator with {1} arguments, but the decorator expects {0}."),
+        The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0: diag(1278, ts.DiagnosticCategory.Error, "The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0_1278", "The runtime will invoke the decorator with {1} arguments, but the decorator expects at least {0}."),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
         The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, ts.DiagnosticCategory.Error, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
@@ -9550,11 +9552,7 @@ var ts;
     }
     ts.getTypeParameterOwner = getTypeParameterOwner;
     function isParameterPropertyDeclaration(node, parent) {
-        return ts.isParameter(node) &&
-            !!node.name &&
-            ts.isIdentifier(node.name) &&
-            ts.isConstructorDeclaration(parent) &&
-            ts.hasSyntacticModifier(node, 16476);
+        return ts.hasSyntacticModifier(node, 16476) && parent.kind === 173;
     }
     ts.isParameterPropertyDeclaration = isParameterPropertyDeclaration;
     function isEmptyBindingPattern(node) {
@@ -11930,6 +11928,11 @@ var ts;
         return createFileDiagnosticFromMessageChain(sourceFile, span.start, span.length, messageChain, relatedInformation);
     }
     ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain;
+    function createDiagnosticForNodeArrayFromMessageChain(sourceFile, nodes, messageChain, relatedInformation) {
+        var start = ts.skipTrivia(sourceFile.text, nodes.pos);
+        return createFileDiagnosticFromMessageChain(sourceFile, start, nodes.end - start, messageChain, relatedInformation);
+    }
+    ts.createDiagnosticForNodeArrayFromMessageChain = createDiagnosticForNodeArrayFromMessageChain;
     function assertDiagnosticLocation(file, start, length) {
         ts.Debug.assertGreaterThanOrEqual(start, 0);
         ts.Debug.assertGreaterThanOrEqual(length, 0);
@@ -23200,9 +23203,9 @@ var ts;
             context.requestEmitHelper(ts.propKeyHelper);
             return factory.createCallExpression(getUnscopedHelperName("__propKey"), undefined, [expr]);
         }
-        function createSetFunctionNameHelper(f, name) {
+        function createSetFunctionNameHelper(f, name, prefix) {
             context.requestEmitHelper(ts.setFunctionNameHelper);
-            return factory.createCallExpression(getUnscopedHelperName("__setFunctionName"), undefined, [f, name]);
+            return context.factory.createCallExpression(getUnscopedHelperName("__setFunctionName"), undefined, prefix ? [f, name, context.factory.createStringLiteral(prefix)] : [f, name]);
         }
         function createValuesHelper(expression) {
             context.requestEmitHelper(ts.valuesHelper);
@@ -23413,7 +23416,7 @@ var ts;
         name: "typescript:setFunctionName",
         importName: "__setFunctionName",
         scoped: false,
-        text: "\n            var __setFunctionName = (this && this.__setFunctionName) || function (f, name) {\n                if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n                return Object.defineProperty(f, \"name\", { configurable: true, value: name });\n            };"
+        text: "\n            var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {\n                if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\n                return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\n            };"
     };
     ts.valuesHelper = {
         name: "typescript:values",
@@ -33077,9 +33080,6 @@ var ts;
             name: "listFilesOnly",
             type: "boolean",
             category: ts.Diagnostics.Command_line_Options,
-            affectsSemanticDiagnostics: true,
-            affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             isCommandLineOnly: true,
             description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
             defaultValueDescription: false,
@@ -34703,6 +34703,7 @@ var ts;
             return (__assign(__assign({}, prev), (_a = {}, _a[cur[0]] = cur[1], _a)));
         }, {}));
     }
+    ts.optionMapToObject = optionMapToObject;
     function filterSameAsDefaultInclude(specs) {
         if (!ts.length(specs))
             return undefined;
@@ -34751,6 +34752,7 @@ var ts;
     function serializeCompilerOptions(options, pathOptions) {
         return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
     }
+    ts.serializeCompilerOptions = serializeCompilerOptions;
     function serializeWatchOptions(options) {
         return serializeOptionBaseObject(options, getWatchOptionsNameMap());
     }
@@ -48091,13 +48093,27 @@ var ts;
                 return getTypeFromTypeNode(typeNode);
             }
         }
+        function isParameterOfContextSensitiveSignature(symbol) {
+            var decl = symbol.valueDeclaration;
+            if (!decl) {
+                return false;
+            }
+            if (ts.isBindingElement(decl)) {
+                decl = ts.walkUpBindingElementsAndPatterns(decl);
+            }
+            if (ts.isParameter(decl)) {
+                return isContextSensitiveFunctionOrObjectLiteralMethod(decl.parent);
+            }
+            return false;
+        }
         function getTypeOfVariableOrParameterOrProperty(symbol) {
             var links = getSymbolLinks(symbol);
             if (!links.type) {
                 var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
-                if (!links.type) {
+                if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
                     links.type = type;
                 }
+                return type;
             }
             return links.type;
         }
@@ -60263,6 +60279,7 @@ var ts;
                     ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
         }
         function getExplicitTypeOfSymbol(symbol, diagnostic) {
+            symbol = resolveSymbol(symbol);
             if (symbol.flags & (16 | 8192 | 32 | 512)) {
                 return getTypeOfSymbol(symbol);
             }
@@ -60297,7 +60314,7 @@ var ts;
                 switch (node.kind) {
                     case 79:
                         var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
-                        return getExplicitTypeOfSymbol(symbol.flags & 2097152 ? resolveAlias(symbol) : symbol, diagnostic);
+                        return getExplicitTypeOfSymbol(symbol, diagnostic);
                     case 108:
                         return getExplicitThisType(node);
                     case 106:
@@ -65311,10 +65328,16 @@ var ts;
         function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
             if (ts.isCallExpression(node)) {
                 var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_6 = _a.length;
-                return ts.createFileDiagnostic(sourceFile, start, length_6, message, arg0, arg1, arg2, arg3);
+                if ("message" in message) {
+                    return ts.createFileDiagnostic(sourceFile, start, length_6, message, arg0, arg1, arg2, arg3);
+                }
+                return ts.createDiagnosticForFileFromMessageChain(sourceFile, message);
             }
             else {
-                return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
+                if ("message" in message) {
+                    return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
+                }
+                return ts.createDiagnosticForNodeFromMessageChain(node, message);
             }
         }
         function isPromiseResolveArityError(node) {
@@ -65331,7 +65354,7 @@ var ts;
             var constructorSymbol = getSymbolAtLocation(decl.parent.parent.expression, true);
             return constructorSymbol === globalPromiseSymbol;
         }
-        function getArgumentArityError(node, signatures, args) {
+        function getArgumentArityError(node, signatures, args, headMessage) {
             var _a;
             var spreadIndex = getSpreadArgumentIndex(args);
             if (spreadIndex > -1) {
@@ -65364,16 +65387,30 @@ var ts;
             if (isVoidPromiseError && ts.isInJSFile(node)) {
                 return getDiagnosticForCallNode(node, ts.Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments);
             }
-            var error = hasRestParameter
-                ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1
-                : isVoidPromiseError
-                    ? ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise
-                    : ts.Diagnostics.Expected_0_arguments_but_got_1;
+            var error = ts.isDecorator(node) ?
+                hasRestParameter ? ts.Diagnostics.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_at_least_0 :
+                    ts.Diagnostics.The_runtime_will_invoke_the_decorator_with_1_arguments_but_the_decorator_expects_0 :
+                hasRestParameter ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1 :
+                    isVoidPromiseError ? ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise :
+                        ts.Diagnostics.Expected_0_arguments_but_got_1;
             if (min < args.length && args.length < max) {
+                if (headMessage) {
+                    var chain = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, args.length, maxBelow, minAbove);
+                    chain = ts.chainDiagnosticMessages(chain, headMessage);
+                    return getDiagnosticForCallNode(node, chain);
+                }
                 return getDiagnosticForCallNode(node, ts.Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, args.length, maxBelow, minAbove);
             }
             else if (args.length < min) {
-                var diagnostic = getDiagnosticForCallNode(node, error, parameterRange, args.length);
+                var diagnostic = void 0;
+                if (headMessage) {
+                    var chain = ts.chainDiagnosticMessages(undefined, error, parameterRange, args.length);
+                    chain = ts.chainDiagnosticMessages(chain, headMessage);
+                    diagnostic = getDiagnosticForCallNode(node, chain);
+                }
+                else {
+                    diagnostic = getDiagnosticForCallNode(node, error, parameterRange, args.length);
+                }
                 var parameter = (_a = closestSignature === null || closestSignature === void 0 ? void 0 : closestSignature.declaration) === null || _a === void 0 ? void 0 : _a.parameters[closestSignature.thisParameter ? args.length + 1 : args.length];
                 if (parameter) {
                     var parameterError = ts.createDiagnosticForNode(parameter, ts.isBindingPattern(parameter.name) ? ts.Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided
@@ -65391,15 +65428,25 @@ var ts;
                     end++;
                 }
                 ts.setTextRangePosEnd(errorSpan, pos, end);
+                if (headMessage) {
+                    var chain = ts.chainDiagnosticMessages(undefined, error, parameterRange, args.length);
+                    chain = ts.chainDiagnosticMessages(chain, headMessage);
+                    return ts.createDiagnosticForNodeArrayFromMessageChain(ts.getSourceFileOfNode(node), errorSpan, chain);
+                }
                 return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), errorSpan, error, parameterRange, args.length);
             }
         }
-        function getTypeArgumentArityError(node, signatures, typeArguments) {
+        function getTypeArgumentArityError(node, signatures, typeArguments, headMessage) {
             var argCount = typeArguments.length;
             if (signatures.length === 1) {
                 var sig = signatures[0];
                 var min_1 = getMinTypeArgumentCount(sig.typeParameters);
                 var max = ts.length(sig.typeParameters);
+                if (headMessage) {
+                    var chain = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Expected_0_type_arguments_but_got_1, min_1 < max ? min_1 + "-" + max : min_1, argCount);
+                    chain = ts.chainDiagnosticMessages(chain, headMessage);
+                    return ts.createDiagnosticForNodeArrayFromMessageChain(ts.getSourceFileOfNode(node), typeArguments, chain);
+                }
                 return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, min_1 < max ? min_1 + "-" + max : min_1, argCount);
             }
             var belowArgCount = -Infinity;
@@ -65416,11 +65463,21 @@ var ts;
                 }
             }
             if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) {
+                if (headMessage) {
+                    var chain = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount);
+                    chain = ts.chainDiagnosticMessages(chain, headMessage);
+                    return ts.createDiagnosticForNodeArrayFromMessageChain(ts.getSourceFileOfNode(node), typeArguments, chain);
+                }
                 return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount);
             }
+            if (headMessage) {
+                var chain = ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
+                chain = ts.chainDiagnosticMessages(chain, headMessage);
+                return ts.createDiagnosticForNodeArrayFromMessageChain(ts.getSourceFileOfNode(node), typeArguments, chain);
+            }
             return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
         }
-        function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) {
+        function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, headMessage) {
             var isTaggedTemplate = node.kind === 212;
             var isDecorator = node.kind === 167;
             var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node);
@@ -65469,6 +65526,9 @@ var ts;
                             chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.The_last_overload_gave_the_following_error);
                             chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.No_overload_matches_this_call);
                         }
+                        if (headMessage) {
+                            chain_1 = ts.chainDiagnosticMessages(chain_1, headMessage);
+                        }
                         var diags = getSignatureApplicabilityError(node, args, last_2, assignableRelation, 0, true, function () { return chain_1; });
                         if (diags) {
                             for (var _i = 0, diags_1 = diags; _i < diags_1.length; _i++) {
@@ -65513,6 +65573,9 @@ var ts;
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
                         var chain = ts.chainDiagnosticMessages(ts.map(diags_3, ts.createDiagnosticMessageChainFromDiagnostic), ts.Diagnostics.No_overload_matches_this_call);
+                        if (headMessage) {
+                            chain = ts.chainDiagnosticMessages(chain, headMessage);
+                        }
                         var related = __spreadArray([], ts.flatMap(diags_3, function (d) { return d.relatedInformation; }), true);
                         var diag = void 0;
                         if (ts.every(diags_3, function (d) { return d.start === diags_3[0].start && d.length === diags_3[0].length && d.file === diags_3[0].file; })) {
@@ -65527,21 +65590,18 @@ var ts;
                     }
                 }
                 else if (candidateForArgumentArityError) {
-                    diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args));
+                    diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args, headMessage));
                 }
                 else if (candidateForTypeArgumentError) {
-                    checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, fallbackError);
+                    checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, headMessage);
                 }
                 else {
                     var signaturesWithCorrectTypeArgumentArity = ts.filter(signatures, function (s) { return hasCorrectTypeArgumentArity(s, typeArguments); });
                     if (signaturesWithCorrectTypeArgumentArity.length === 0) {
-                        diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments));
+                        diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments, headMessage));
                     }
-                    else if (!isDecorator) {
-                        diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args));
-                    }
-                    else if (fallbackError) {
-                        diagnostics.add(getDiagnosticForCallNode(node, fallbackError));
+                    else {
+                        diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args, headMessage));
                     }
                 }
             }
@@ -66062,7 +66122,7 @@ var ts;
             if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
                 return resolveUntypedCall(node);
             }
-            if (isPotentiallyUncalledDecorator(node, callSignatures)) {
+            if (isPotentiallyUncalledDecorator(node, callSignatures) && !ts.isParenthesizedExpression(node.expression)) {
                 var nodeStr = ts.getTextOfNode(node.expression, false);
                 error(node, ts.Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr);
                 return resolveErrorCall(node);
@@ -70535,7 +70595,7 @@ var ts;
                 default:
                     return ts.Debug.failBadSyntaxKind(node.parent);
             }
-            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage);
+            checkTypeAssignableTo(returnType, expectedReturnType, node.expression, headMessage);
         }
         function createCallSignature(typeParameters, thisParameter, parameters, returnType, typePredicate, minArgumentCount, flags) {
             if (minArgumentCount === void 0) { minArgumentCount = parameters.length; }
@@ -83280,14 +83340,12 @@ var ts;
                 factory.createVariableDeclaration(name, undefined, undefined, initializer),
             ], 1));
         }
-        function createAssign(left, right) {
-            return factory.createExpressionStatement(factory.createAssignment(left, right));
-        }
         function createClassInfo(node) {
             var instanceExtraInitializersName;
             var staticExtraInitializersName;
             var hasStaticInitializers = false;
             var hasNonAmbientInstanceFields = false;
+            var hasStaticPrivateClassElements = false;
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
                 if (ts.isNamedClassElement(member) && ts.nodeOrChildIsDecorated(false, member, node)) {
@@ -83309,10 +83367,14 @@ var ts;
                         hasNonAmbientInstanceFields || (hasNonAmbientInstanceFields = !ts.isAmbientPropertyDeclaration(member));
                     }
                 }
+                if ((ts.isPrivateIdentifierClassElementDeclaration(member) || ts.isAutoAccessorPropertyDeclaration(member)) && ts.hasStaticModifier(member)) {
+                    hasStaticPrivateClassElements = true;
+                }
                 if (staticExtraInitializersName &&
                     instanceExtraInitializersName &&
                     hasStaticInitializers &&
-                    hasNonAmbientInstanceFields) {
+                    hasNonAmbientInstanceFields &&
+                    hasStaticPrivateClassElements) {
                     break;
                 }
             }
@@ -83322,6 +83384,7 @@ var ts;
                 staticExtraInitializersName: staticExtraInitializersName,
                 hasStaticInitializers: hasStaticInitializers,
                 hasNonAmbientInstanceFields: hasNonAmbientInstanceFields,
+                hasStaticPrivateClassElements: hasStaticPrivateClassElements,
             };
         }
         function containsLexicalSuperInStaticInitializer(node) {
@@ -83354,13 +83417,9 @@ var ts;
                 classInfo.classExtraInitializersName = factory.createUniqueName("_classExtraInitializers", 16);
                 classInfo.classThis = factory.createUniqueName("_classThis", 16);
                 classDefinitionStatements.push(createLet(classInfo.classDecoratorsName, factory.createArrayLiteralExpression(classDecorators)), createLet(classInfo.classDescriptorName), createLet(classInfo.classExtraInitializersName, factory.createArrayLiteralExpression()), createLet(classInfo.classThis));
-                for (var _i = 0, _f = node.members; _i < _f.length; _i++) {
-                    var member = _f[_i];
-                    if ((ts.isPrivateIdentifierClassElementDeclaration(member) || ts.isAutoAccessorPropertyDeclaration(member)) && ts.hasStaticModifier(member)) {
-                        shouldTransformPrivateStaticElementsInClass = true;
-                        shouldTransformPrivateStaticElementsInFile = true;
-                        break;
-                    }
+                if (classInfo.hasStaticPrivateClassElements) {
+                    shouldTransformPrivateStaticElementsInClass = true;
+                    shouldTransformPrivateStaticElementsInFile = true;
                 }
             }
             if (classDecorators && containsLexicalSuperInStaticInitializer(node)) {
@@ -83393,8 +83452,8 @@ var ts;
             enterClass(classInfo);
             var members = ts.visitNodes(node.members, classElementVisitor, ts.isClassElement);
             if (pendingExpressions) {
-                for (var _g = 0, pendingExpressions_2 = pendingExpressions; _g < pendingExpressions_2.length; _g++) {
-                    var expression = pendingExpressions_2[_g];
+                for (var _i = 0, pendingExpressions_2 = pendingExpressions; _i < pendingExpressions_2.length; _i++) {
+                    var expression = pendingExpressions_2[_i];
                     var statement = factory.createExpressionStatement(expression);
                     leadingBlockStatements = ts.append(leadingBlockStatements, statement);
                 }
@@ -83519,8 +83578,8 @@ var ts;
             }
             if (shouldTransformPrivateStaticElementsInClass) {
                 ts.addInternalEmitFlags(classExpression, 32);
-                for (var _h = 0, _j = classExpression.members; _h < _j.length; _h++) {
-                    var member = _j[_h];
+                for (var _f = 0, _g = classExpression.members; _f < _g.length; _f++) {
+                    var member = _g[_f];
                     if ((ts.isPrivateIdentifierClassElementDeclaration(member) || ts.isAutoAccessorPropertyDeclaration(member)) && ts.hasStaticModifier(member)) {
                         ts.addInternalEmitFlags(member, 32);
                     }
@@ -83585,28 +83644,10 @@ var ts;
                 return factory.updateClassExpression(node, modifiers, node.name, undefined, heritageClauses, members);
             }
         }
-        function prepareConstructor(parent, classInfo) {
-            var _a, _b;
+        function prepareConstructor(_parent, classInfo) {
             if (classInfo.instanceExtraInitializersName && !classInfo.hasNonAmbientInstanceFields) {
                 var statements = [];
                 statements.push(factory.createExpressionStatement(emitHelpers().createRunInitializersHelper(factory.createThis(), classInfo.instanceExtraInitializersName)));
-                for (var _i = 0, _c = parent.members; _i < _c.length; _i++) {
-                    var member = _c[_i];
-                    if (ts.isPropertyDeclaration(member) && !ts.isStatic(member)) {
-                        ts.Debug.assertNotNode(member.name, ts.isComputedPropertyName, "Not yet implemented.");
-                        var initializer = member.initializer;
-                        var initializers = (_b = (_a = classInfo.memberInfos) === null || _a === void 0 ? void 0 : _a.get(member)) === null || _b === void 0 ? void 0 : _b.memberInitializersName;
-                        if (initializer || initializers) {
-                            initializer !== null && initializer !== void 0 ? initializer : (initializer = factory.createVoidZero());
-                            if (initializers) {
-                                initializer = emitHelpers().createRunInitializersHelper(factory.createThis(), initializers, initializer);
-                            }
-                            statements.push(createAssign(ts.isIdentifier(member.name) || ts.isPrivateIdentifier(member.name) ?
-                                factory.createPropertyAccessExpression(factory.createThis(), member.name) :
-                                factory.createElementAccessExpression(factory.createThis(), member.name), initializer));
-                        }
-                    }
-                }
                 return statements;
             }
         }
@@ -83615,7 +83656,7 @@ var ts;
             var modifiers = ts.visitNodes(node.modifiers, function (node) { return ts.tryCast(node, ts.isModifier); });
             var parameters = ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration);
             var body;
-            if (node.body && (classInfo === null || classInfo === void 0 ? void 0 : classInfo.instanceExtraInitializersName)) {
+            if (node.body && classInfo) {
                 var initializerStatements = prepareConstructor(classInfo.class, classInfo);
                 if (initializerStatements) {
                     var statements = [];
@@ -83833,45 +83874,43 @@ var ts;
                 ], false));
             }
             exitClassElement();
-            if (ts.hasAccessorModifier(node)) {
-                if (descriptorName) {
-                    var commentRange = ts.getCommentRange(node);
-                    var sourceMapRange = ts.getSourceMapRange(node);
-                    var name_8 = node.name;
-                    var getterName = name_8;
-                    var setterName = name_8;
-                    if (ts.isComputedPropertyName(name_8) && !ts.isSimpleInlineableExpression(name_8.expression)) {
-                        var cacheAssignment = ts.findComputedPropertyNameCacheAssignment(name_8);
-                        if (cacheAssignment) {
-                            getterName = factory.updateComputedPropertyName(name_8, ts.visitNode(name_8.expression, visitor, ts.isExpression));
-                            setterName = factory.updateComputedPropertyName(name_8, cacheAssignment.left);
-                        }
-                        else {
-                            var temp = factory.createTempVariable(hoistVariableDeclaration);
-                            ts.setSourceMapRange(temp, name_8.expression);
-                            var expression = ts.visitNode(name_8.expression, visitor, ts.isExpression);
-                            var assignment = factory.createAssignment(temp, expression);
-                            ts.setSourceMapRange(assignment, name_8.expression);
-                            getterName = factory.updateComputedPropertyName(name_8, assignment);
-                            setterName = factory.updateComputedPropertyName(name_8, temp);
-                        }
-                    }
-                    var modifiersWithoutAccessor = ts.visitNodes(modifiers, function (node) { return node.kind !== 127 ? node : undefined; });
-                    var backingField = ts.createAccessorPropertyBackingField(factory, node, modifiersWithoutAccessor, initializer);
-                    ts.setOriginalNode(backingField, node);
-                    ts.setEmitFlags(backingField, 1536);
-                    ts.setSourceMapRange(backingField, sourceMapRange);
-                    ts.setSourceMapRange(backingField.name, node.name);
-                    var getter = createGetAccessorDescriptorForwarder(modifiersWithoutAccessor, getterName, descriptorName);
-                    ts.setOriginalNode(getter, node);
-                    ts.setCommentRange(getter, commentRange);
-                    ts.setSourceMapRange(getter, sourceMapRange);
-                    var setter = createSetAccessorDescriptorForwarder(modifiersWithoutAccessor, setterName, descriptorName);
-                    ts.setOriginalNode(setter, node);
-                    ts.setEmitFlags(setter, 1536);
-                    ts.setSourceMapRange(setter, sourceMapRange);
-                    return [backingField, getter, setter];
-                }
+            if (ts.hasAccessorModifier(node) && descriptorName) {
+                var commentRange = ts.getCommentRange(node);
+                var sourceMapRange = ts.getSourceMapRange(node);
+                var name_8 = node.name;
+                var getterName = name_8;
+                var setterName = name_8;
+                if (ts.isComputedPropertyName(name_8) && !ts.isSimpleInlineableExpression(name_8.expression)) {
+                    var cacheAssignment = ts.findComputedPropertyNameCacheAssignment(name_8);
+                    if (cacheAssignment) {
+                        getterName = factory.updateComputedPropertyName(name_8, ts.visitNode(name_8.expression, visitor, ts.isExpression));
+                        setterName = factory.updateComputedPropertyName(name_8, cacheAssignment.left);
+                    }
+                    else {
+                        var temp = factory.createTempVariable(hoistVariableDeclaration);
+                        ts.setSourceMapRange(temp, name_8.expression);
+                        var expression = ts.visitNode(name_8.expression, visitor, ts.isExpression);
+                        var assignment = factory.createAssignment(temp, expression);
+                        ts.setSourceMapRange(assignment, name_8.expression);
+                        getterName = factory.updateComputedPropertyName(name_8, assignment);
+                        setterName = factory.updateComputedPropertyName(name_8, temp);
+                    }
+                }
+                var modifiersWithoutAccessor = ts.visitNodes(modifiers, function (node) { return node.kind !== 127 ? node : undefined; });
+                var backingField = ts.createAccessorPropertyBackingField(factory, node, modifiersWithoutAccessor, initializer);
+                ts.setOriginalNode(backingField, node);
+                ts.setEmitFlags(backingField, 1536);
+                ts.setSourceMapRange(backingField, sourceMapRange);
+                ts.setSourceMapRange(backingField.name, node.name);
+                var getter = createGetAccessorDescriptorForwarder(modifiersWithoutAccessor, getterName, descriptorName);
+                ts.setOriginalNode(getter, node);
+                ts.setCommentRange(getter, commentRange);
+                ts.setSourceMapRange(getter, sourceMapRange);
+                var setter = createSetAccessorDescriptorForwarder(modifiersWithoutAccessor, setterName, descriptorName);
+                ts.setOriginalNode(setter, node);
+                ts.setEmitFlags(setter, 1536);
+                ts.setSourceMapRange(setter, sourceMapRange);
+                return [backingField, getter, setter];
             }
             return finishClassElement(factory.updatePropertyDeclaration(node, modifiers, name, undefined, undefined, initializer), node);
         }
@@ -84250,17 +84289,14 @@ var ts;
             ts.setEmitFlags(expression, 1536);
             return expression;
         }
-        function createDescriptorMethod(original, _name, modifiers, asteriskToken, kind, parameters, body) {
+        function createDescriptorMethod(original, name, modifiers, asteriskToken, kind, parameters, body) {
             var func = factory.createFunctionExpression(modifiers, asteriskToken, undefined, undefined, parameters, undefined, body !== null && body !== void 0 ? body : factory.createBlock([]));
             ts.setOriginalNode(func, original);
             ts.setSourceMapRange(func, ts.moveRangePastDecorators(original));
             ts.setEmitFlags(func, 1536);
-            var functionName = ts.isPropertyNameLiteral(_name) || ts.isPrivateIdentifier(_name) ?
-                factory.createStringLiteralFromNode(_name) :
-                undefined;
-            var namedFunction = functionName ?
-                emitHelpers().createSetFunctionNameHelper(func, functionName) :
-                func;
+            var prefix = kind === "get" || kind === "set" ? kind : undefined;
+            var functionName = factory.createStringLiteralFromNode(name, undefined);
+            var namedFunction = emitHelpers().createSetFunctionNameHelper(func, functionName, prefix);
             var method = factory.createPropertyAssignment(factory.createIdentifier(kind), namedFunction);
             ts.setOriginalNode(method, original);
             ts.setSourceMapRange(method, ts.moveRangePastDecorators(original));
@@ -85509,11 +85545,22 @@ var ts;
             }
             return node;
         }
-        function convertForOfStatementHead(node, boundValue) {
-            var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
+        function convertForOfStatementHead(node, boundValue, nonUserCode) {
+            var value = factory.createTempVariable(hoistVariableDeclaration);
+            var iteratorValueExpression = factory.createAssignment(value, boundValue);
+            var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
+            ts.setSourceMapRange(iteratorValueStatement, node.expression);
+            var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
+            var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
+            ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
+            var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
+            var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
+            ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
+            var statements = [];
+            var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
+            statements.push(ts.visitNode(binding, visitor, ts.isStatement));
             var bodyLocation;
             var statementsLocation;
-            var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
             var statement = ts.visitIterationBody(node.statement, visitor, context);
             if (ts.isBlock(statement)) {
                 ts.addRange(statements, statement.statements);
@@ -85523,7 +85570,14 @@ var ts;
             else {
                 statements.push(statement);
             }
-            return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384);
+            var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), true), bodyLocation), 48 | 384);
+            return factory.createBlock([
+                iteratorValueStatement,
+                exitNonUserCodeStatement,
+                factory.createTryStatement(body, undefined, factory.createBlock([
+                    enterNonUserCodeStatement
+                ]))
+            ]);
         }
         function createDownlevelAwait(expression) {
             return enclosingFunctionFlags & 1
@@ -85534,6 +85588,8 @@ var ts;
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
             var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(undefined);
             var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(undefined);
+            var nonUserCode = factory.createTempVariable(undefined);
+            var done = factory.createTempVariable(hoistVariableDeclaration);
             var errorRecord = factory.createUniqueName("e");
             var catchVariable = factory.getGeneratedNameForNode(errorRecord);
             var returnMethod = factory.createTempVariable(undefined);
@@ -85548,9 +85604,14 @@ var ts;
                 factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), callValues]) :
                 callValues;
             var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
+                factory.createVariableDeclaration(nonUserCode, undefined, undefined, factory.createTrue()),
                 ts.setTextRange(factory.createVariableDeclaration(iterator, undefined, undefined, initializer), node.expression),
                 factory.createVariableDeclaration(result)
-            ]), node.expression), 2097152), factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)), undefined, convertForOfStatementHead(node, getValue)), node), 256);
+            ]), node.expression), 2097152), factory.inlineExpressions([
+                factory.createAssignment(result, createDownlevelAwait(callNext)),
+                factory.createAssignment(done, getDone),
+                factory.createLogicalNot(done)
+            ]), undefined, convertForOfStatementHead(node, getValue, nonUserCode)), node), 256);
             ts.setOriginalNode(forStatement, node);
             return factory.createTryStatement(factory.createBlock([
                 factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement)
@@ -85560,7 +85621,7 @@ var ts;
                 ])))
             ]), 1)), factory.createBlock([
                 factory.createTryStatement(factory.createBlock([
-                    ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1)
+                    ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1)
                 ]), undefined, ts.setEmitFlags(factory.createBlock([
                     ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1)
                 ]), 1))
@@ -89672,19 +89733,23 @@ var ts;
         }
         function transformAndEmitForInStatement(node) {
             if (containsYield(node)) {
+                var obj = declareLocal();
                 var keysArray = declareLocal();
                 var key = declareLocal();
                 var keysIndex = factory.createLoopVariable();
                 var initializer = node.initializer;
                 hoistVariableDeclaration(keysIndex);
+                emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
                 emitAssignment(keysArray, factory.createArrayLiteralExpression());
-                emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), undefined, [key]))));
+                emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), undefined, [key]))));
                 emitAssignment(keysIndex, factory.createNumericLiteral(0));
                 var conditionLabel = defineLabel();
                 var incrementLabel = defineLabel();
-                var endLabel = beginLoopBlock(incrementLabel);
+                var endLoopLabel = beginLoopBlock(incrementLabel);
                 markLabel(conditionLabel);
-                emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
+                emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
+                emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
+                emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101, obj));
                 var variable = void 0;
                 if (ts.isVariableDeclarationList(initializer)) {
                     for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -89697,7 +89762,7 @@ var ts;
                     variable = ts.visitNode(initializer, visitor, ts.isExpression);
                     ts.Debug.assert(ts.isLeftHandSideExpression(variable));
                 }
-                emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
+                emitAssignment(variable, key);
                 transformAndEmitEmbeddedStatement(node.statement);
                 markLabel(incrementLabel);
                 emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
@@ -100340,14 +100405,16 @@ var ts;
             }
             return setReadFileCache(key, fileName);
         };
-        var getSourceFileWithCache = getSourceFile ? function (fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+        var getSourceFileWithCache = getSourceFile ? function (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
             var key = toPath(fileName);
-            var value = sourceFileCache.get(key);
+            var impliedNodeFormat = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.impliedNodeFormat : undefined;
+            var forImpliedNodeFormat = sourceFileCache.get(impliedNodeFormat);
+            var value = forImpliedNodeFormat === null || forImpliedNodeFormat === void 0 ? void 0 : forImpliedNodeFormat.get(key);
             if (value)
                 return value;
-            var sourceFile = getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+            var sourceFile = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
             if (sourceFile && (ts.isDeclarationFileName(fileName) || ts.fileExtensionIs(fileName, ".json"))) {
-                sourceFileCache.set(key, sourceFile);
+                sourceFileCache.set(impliedNodeFormat, (forImpliedNodeFormat || new ts.Map()).set(key, sourceFile));
             }
             return sourceFile;
         } : undefined;
@@ -100371,13 +100438,15 @@ var ts;
                 var value = readFileCache.get(key);
                 if (value !== undefined && value !== data) {
                     readFileCache.delete(key);
-                    sourceFileCache.delete(key);
+                    sourceFileCache.forEach(function (map) { return map.delete(key); });
                 }
                 else if (getSourceFileWithCache) {
-                    var sourceFile = sourceFileCache.get(key);
-                    if (sourceFile && sourceFile.text !== data) {
-                        sourceFileCache.delete(key);
-                    }
+                    sourceFileCache.forEach(function (map) {
+                        var sourceFile = map.get(key);
+                        if (sourceFile && sourceFile.text !== data) {
+                            map.delete(key);
+                        }
+                    });
                 }
                 originalWriteFile.call.apply(originalWriteFile, __spreadArray([host, fileName, data], rest, false));
             };
@@ -104430,7 +104499,8 @@ var ts;
             for (var _b = 0, _c = state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(ts.compareStringsCaseSensitive); _b < _c.length; _b++) {
                 var path = _c[_b];
                 if (ts.tryAddToSet(seenFiles, path)) {
-                    (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push([toFileId(path), state.affectedFilesPendingEmitKind.get(path)]);
+                    var fileId = toFileId(path), emitKind = state.affectedFilesPendingEmitKind.get(path);
+                    (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push(emitKind === 1 ? fileId : [fileId]);
                 }
             }
         }
@@ -104835,6 +104905,10 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
+    function toBuilderFileEmit(value) {
+        return ts.isNumber(value) ? 1 : 0;
+    }
+    ts.toBuilderFileEmit = toBuilderFileEmit;
     function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
         var _a, _b, _c, _d;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
@@ -104876,8 +104950,8 @@ var ts;
                 exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
                 semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }),
                 hasReusableDiagnostic: true,
-                affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
-                affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
+                affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }),
+                affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, toBuilderFileEmit),
                 affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
                 changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
                 latestChangedDtsFile: latestChangedDtsFile,