typescript 4.3.0-dev.20210510 → 4.3.4

package/lib/typescript.js

@@ -290,7 +290,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.20210510";
+    ts.version = "4.3.4";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7883,7 +7883,7 @@ var ts;
         Identifier_expected: diag(1003, ts.DiagnosticCategory.Error, "Identifier_expected_1003", "Identifier expected."),
         _0_expected: diag(1005, ts.DiagnosticCategory.Error, "_0_expected_1005", "'{0}' expected."),
         A_file_cannot_have_a_reference_to_itself: diag(1006, ts.DiagnosticCategory.Error, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."),
-        The_parser_expected_to_find_a_1_to_match_the_0_token_here: diag(1007, ts.DiagnosticCategory.Error, "The_parser_expected_to_find_a_1_to_match_the_0_token_here_1007", "The parser expected to find a '{1}' to match the '{0}' token here."),
+        The_parser_expected_to_find_a_to_match_the_token_here: diag(1007, ts.DiagnosticCategory.Error, "The_parser_expected_to_find_a_to_match_the_token_here_1007", "The parser expected to find a '}' to match the '{' token here."),
         Trailing_comma_not_allowed: diag(1009, ts.DiagnosticCategory.Error, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."),
         Asterisk_Slash_expected: diag(1010, ts.DiagnosticCategory.Error, "Asterisk_Slash_expected_1010", "'*/' expected."),
         An_element_access_expression_should_take_an_argument: diag(1011, ts.DiagnosticCategory.Error, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."),
@@ -17515,56 +17515,43 @@ var ts;
         }
         return __assign(__assign({}, writer), { writeTrailingSemicolon: function () {
                 pendingTrailingSemicolon = true;
-            },
-            writeLiteral: function (s) {
+            }, writeLiteral: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeLiteral(s);
-            },
-            writeStringLiteral: function (s) {
+            }, writeStringLiteral: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeStringLiteral(s);
-            },
-            writeSymbol: function (s, sym) {
+            }, writeSymbol: function (s, sym) {
                 commitPendingTrailingSemicolon();
                 writer.writeSymbol(s, sym);
-            },
-            writePunctuation: function (s) {
+            }, writePunctuation: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writePunctuation(s);
-            },
-            writeKeyword: function (s) {
+            }, writeKeyword: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeKeyword(s);
-            },
-            writeOperator: function (s) {
+            }, writeOperator: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeOperator(s);
-            },
-            writeParameter: function (s) {
+            }, writeParameter: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeParameter(s);
-            },
-            writeSpace: function (s) {
+            }, writeSpace: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeSpace(s);
-            },
-            writeProperty: function (s) {
+            }, writeProperty: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeProperty(s);
-            },
-            writeComment: function (s) {
+            }, writeComment: function (s) {
                 commitPendingTrailingSemicolon();
                 writer.writeComment(s);
-            },
-            writeLine: function () {
+            }, writeLine: function () {
                 commitPendingTrailingSemicolon();
                 writer.writeLine();
-            },
-            increaseIndent: function () {
+            }, increaseIndent: function () {
                 commitPendingTrailingSemicolon();
                 writer.increaseIndent();
-            },
-            decreaseIndent: function () {
+            }, decreaseIndent: function () {
                 commitPendingTrailingSemicolon();
                 writer.decreaseIndent();
             } });
@@ -29462,8 +29449,8 @@ var ts;
                             visitNode(cbNode, node.typeExpression) ||
                             (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))
                         : visitNode(cbNode, node.typeExpression) ||
-                            visitNode(cbNode, node.name)) ||
-                    (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
+                            visitNode(cbNode, node.name) ||
+                            (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)));
             case 320 /* JSDocAuthorTag */:
                 return visitNode(cbNode, node.tagName) ||
                     (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment));
@@ -30224,23 +30211,20 @@ var ts;
             return inContext(32768 /* AwaitContext */);
         }
         function parseErrorAtCurrentToken(message, arg0) {
-            return parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
+            parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
         }
         function parseErrorAtPosition(start, length, message, arg0) {
             // Don't report another error if it would just be at the same position as the last error.
             var lastError = ts.lastOrUndefined(parseDiagnostics);
-            var result;
             if (!lastError || start !== lastError.start) {
-                result = ts.createDetachedDiagnostic(fileName, start, length, message, arg0);
-                parseDiagnostics.push(result);
+                parseDiagnostics.push(ts.createDetachedDiagnostic(fileName, start, length, message, arg0));
             }
             // Mark that we've encountered an error.  We'll set an appropriate bit on the next
             // node we finish so that it can't be reused incrementally.
             parseErrorBeforeNextFinishedNode = true;
-            return result;
         }
         function parseErrorAt(start, end, message, arg0) {
-            return parseErrorAtPosition(start, end - start, message, arg0);
+            parseErrorAtPosition(start, end - start, message, arg0);
         }
         function parseErrorAtRange(range, message, arg0) {
             parseErrorAt(range.pos, range.end, message, arg0);
@@ -30397,16 +30381,6 @@ var ts;
             parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
             return false;
         }
-        function parseExpectedMatchingBrackets(openKind, closeKind, openPosition) {
-            if (token() === closeKind) {
-                nextToken();
-                return;
-            }
-            var lastError = parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(closeKind));
-            if (lastError) {
-                ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openPosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, ts.tokenToString(openKind), ts.tokenToString(closeKind)));
-            }
-        }
         function parseOptional(t) {
             if (token() === t) {
                 nextToken();
@@ -33774,11 +33748,10 @@ var ts;
         }
         function parseArrayLiteralExpression() {
             var pos = getNodePos();
-            var openBracketPosition = scanner.getTokenPos();
             parseExpected(22 /* OpenBracketToken */);
             var multiLine = scanner.hasPrecedingLineBreak();
             var elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
-            parseExpectedMatchingBrackets(22 /* OpenBracketToken */, 23 /* CloseBracketToken */, openBracketPosition);
+            parseExpected(23 /* CloseBracketToken */);
             return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos);
         }
         function parseObjectLiteralElement() {
@@ -33838,7 +33811,12 @@ var ts;
             parseExpected(18 /* OpenBraceToken */);
             var multiLine = scanner.hasPrecedingLineBreak();
             var properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimiter*/ true);
-            parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBracePosition);
+            if (!parseExpected(19 /* CloseBraceToken */)) {
+                var lastError = ts.lastOrUndefined(parseDiagnostics);
+                if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
+                    ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
+                }
+            }
             return finishNode(factory.createObjectLiteralExpression(properties, multiLine), pos);
         }
         function parseFunctionExpression() {
@@ -33912,7 +33890,12 @@ var ts;
             if (parseExpected(18 /* OpenBraceToken */, diagnosticMessage) || ignoreMissingOpenBrace) {
                 var multiLine = scanner.hasPrecedingLineBreak();
                 var statements = parseList(1 /* BlockStatements */, parseStatement);
-                parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBracePosition);
+                if (!parseExpected(19 /* CloseBraceToken */)) {
+                    var lastError = ts.lastOrUndefined(parseDiagnostics);
+                    if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
+                        ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
+                    }
+                }
                 var result = withJSDoc(finishNode(factory.createBlock(statements, multiLine), pos), hasJSDoc);
                 if (token() === 62 /* EqualsToken */) {
                     parseErrorAtCurrentToken(ts.Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses);
@@ -33957,10 +33940,9 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(98 /* IfKeyword */);
-            var openParenPosition = scanner.getTokenPos();
             parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenPosition);
+            parseExpected(21 /* CloseParenToken */);
             var thenStatement = parseStatement();
             var elseStatement = parseOptional(90 /* ElseKeyword */) ? parseStatement() : undefined;
             return withJSDoc(finishNode(factory.createIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc);
@@ -33971,10 +33953,9 @@ var ts;
             parseExpected(89 /* DoKeyword */);
             var statement = parseStatement();
             parseExpected(114 /* WhileKeyword */);
-            var openParenPosition = scanner.getTokenPos();
             parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenPosition);
+            parseExpected(21 /* CloseParenToken */);
             // From: https://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html
             // 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in
             // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby
@@ -33986,10 +33967,9 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(114 /* WhileKeyword */);
-            var openParenPosition = scanner.getTokenPos();
             parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenPosition);
+            parseExpected(21 /* CloseParenToken */);
             var statement = parseStatement();
             return withJSDoc(finishNode(factory.createWhileStatement(expression, statement), pos), hasJSDoc);
         }
@@ -34056,10 +34036,9 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(115 /* WithKeyword */);
-            var openParenPosition = scanner.getTokenPos();
             parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenPosition);
+            parseExpected(21 /* CloseParenToken */);
             var statement = doInsideOfContext(16777216 /* InWithStatement */, parseStatement);
             return withJSDoc(finishNode(factory.createWithStatement(expression, statement), pos), hasJSDoc);
         }
@@ -36050,7 +36029,8 @@ var ts;
                             hasChildren = true;
                             if (child.kind === 333 /* JSDocTypeTag */) {
                                 if (childTypeTag) {
-                                    var lastError = parseErrorAtCurrentToken(ts.Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
+                                    parseErrorAtCurrentToken(ts.Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
+                                    var lastError = ts.lastOrUndefined(parseDiagnostics);
                                     if (lastError) {
                                         ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, 0, 0, ts.Diagnostics.The_tag_was_first_specified_here));
                                     }
@@ -37583,6 +37563,8 @@ var ts;
         {
             name: "strict",
             type: "boolean",
+            // Though this affects semantic diagnostics, affectsSemanticDiagnostics is not set here
+            // The value of each strictFlag depends on own strictFlag value or this and never accessed directly.
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Strict_Type_Checking_Options,
             description: ts.Diagnostics.Enable_all_strict_type_checking_options
@@ -40504,9 +40486,7 @@ var ts;
         var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
         moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
         var packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
-        return __assign(__assign(__assign({}, packageJsonInfoCache), preDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName,
-            clear: clear,
-            update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; } });
+        return __assign(__assign(__assign({}, packageJsonInfoCache), preDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; } });
         function clear() {
             preDirectoryResolutionCache.clear();
             moduleNameToDirectoryMap.clear();
@@ -56211,6 +56191,10 @@ var ts;
             var indexSymbol = symbol && getIndexSymbol(symbol);
             return indexSymbol && getIndexDeclarationOfIndexSymbol(indexSymbol, kind);
         }
+        function getIndexDeclarationOfSymbolTable(symbolTable, kind) {
+            var indexSymbol = symbolTable && getIndexSymbolFromSymbolTable(symbolTable);
+            return indexSymbol && getIndexDeclarationOfIndexSymbol(indexSymbol, kind);
+        }
         function getIndexDeclarationOfIndexSymbol(indexSymbol, kind) {
             var syntaxKind = kind === 1 /* Number */ ? 144 /* NumberKeyword */ : 147 /* StringKeyword */;
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
@@ -59365,8 +59349,7 @@ var ts;
             return type;
         }
         function maybeTypeParameterReference(node) {
-            return !(node.kind === 158 /* QualifiedName */ ||
-                node.parent.kind === 174 /* TypeReference */ && node.parent.typeArguments && node === node.parent.typeName ||
+            return !(node.parent.kind === 174 /* TypeReference */ && node.parent.typeArguments && node === node.parent.typeName ||
                 node.parent.kind === 196 /* ImportType */ && node.parent.typeArguments && node === node.parent.qualifier);
         }
         function isTypeParameterPossiblyReferenced(tp, node) {
@@ -59394,7 +59377,10 @@ var ts;
                         return true;
                     case 166 /* MethodDeclaration */:
                     case 165 /* MethodSignature */:
-                        return (!node.type && !!node.body) || !!ts.forEachChild(node, containsReference);
+                        return !node.type && !!node.body ||
+                            ts.some(node.typeParameters, containsReference) ||
+                            ts.some(node.parameters, containsReference) ||
+                            !!node.type && containsReference(node.type);
                 }
                 return !!ts.forEachChild(node, containsReference);
             }
@@ -63419,14 +63405,17 @@ var ts;
             return type.flags & 32768 /* Undefined */ ? type : getUnionType([type, undefinedType]);
         }
         function getGlobalNonNullableTypeInstantiation(type) {
+            // First reduce away any constituents that are assignable to 'undefined' or 'null'. This not only eliminates
+            // 'undefined' and 'null', but also higher-order types such as a type parameter 'U extends undefined | null'
+            // that isn't eliminated by a NonNullable<T> instantiation.
+            var reducedType = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
             if (!deferredGlobalNonNullableTypeAlias) {
                 deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288 /* TypeAlias */, /*diagnostic*/ undefined) || unknownSymbol;
             }
-            // Use NonNullable global type alias if available to improve quick info/declaration emit
-            if (deferredGlobalNonNullableTypeAlias !== unknownSymbol) {
-                return getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]);
-            }
-            return getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */); // Type alias unavailable, fall back to non-higher-order behavior
+            // If the NonNullable<T> type is available, return an instantiation. Otherwise just return the reduced type.
+            return deferredGlobalNonNullableTypeAlias !== unknownSymbol ?
+                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
+                reducedType;
         }
         function getNonNullableType(type) {
             return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type;
@@ -64774,12 +64763,14 @@ var ts;
                 applyToReturnTypes(source, target, inferFromTypes);
             }
             function inferFromIndexTypes(source, target) {
+                // Inferences across mapped type index signatures are pretty much the same a inferences to homomorphic variables
+                var priority = (ts.getObjectFlags(source) & ts.getObjectFlags(target) & 32 /* Mapped */) ? 8 /* HomomorphicMappedType */ : 0;
                 var targetStringIndexType = getIndexTypeOfType(target, 0 /* String */);
                 if (targetStringIndexType) {
                     var sourceIndexType = getIndexTypeOfType(source, 0 /* String */) ||
                         getImplicitIndexTypeOfType(source, 0 /* String */);
                     if (sourceIndexType) {
-                        inferFromTypes(sourceIndexType, targetStringIndexType);
+                        inferWithPriority(sourceIndexType, targetStringIndexType, priority);
                     }
                 }
                 var targetNumberIndexType = getIndexTypeOfType(target, 1 /* Number */);
@@ -64788,7 +64779,7 @@ var ts;
                         getIndexTypeOfType(source, 0 /* String */) ||
                         getImplicitIndexTypeOfType(source, 1 /* Number */);
                     if (sourceIndexType) {
-                        inferFromTypes(sourceIndexType, targetNumberIndexType);
+                        inferWithPriority(sourceIndexType, targetNumberIndexType, priority);
                     }
                 }
             }
@@ -67014,7 +67005,7 @@ var ts;
                     !isGenericIndexType(getTypeOfExpression(parent.argumentExpression));
         }
         function isGenericTypeWithUnionConstraint(type) {
-            return !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & 1048576 /* Union */);
+            return !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
         }
         function containsGenericType(type) {
             return !!(type.flags & 465829888 /* Instantiable */ || type.flags & 3145728 /* UnionOrIntersection */ && ts.some(type.types, containsGenericType));
@@ -78488,21 +78479,24 @@ var ts;
                 checkBlock(node.finallyBlock);
             }
         }
-        function checkIndexConstraints(type) {
-            var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, 1 /* Number */);
-            var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, 0 /* String */);
+        function checkIndexConstraints(type, isStatic) {
+            var _a, _b, _c, _d;
+            var declaredNumberIndexer = getIndexDeclarationOfSymbolTable(isStatic ? (_a = type.symbol) === null || _a === void 0 ? void 0 : _a.exports : (_b = type.symbol) === null || _b === void 0 ? void 0 : _b.members, 1 /* Number */);
+            var declaredStringIndexer = getIndexDeclarationOfSymbolTable(isStatic ? (_c = type.symbol) === null || _c === void 0 ? void 0 : _c.exports : (_d = type.symbol) === null || _d === void 0 ? void 0 : _d.members, 0 /* String */);
             var stringIndexType = getIndexTypeOfType(type, 0 /* String */);
             var numberIndexType = getIndexTypeOfType(type, 1 /* Number */);
             if (stringIndexType || numberIndexType) {
                 ts.forEach(getPropertiesOfObjectType(type), function (prop) {
+                    if (isStatic && prop.flags & 4194304 /* Prototype */)
+                        return;
                     var propType = getTypeOfSymbol(prop);
                     checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */);
                     checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */);
                 });
                 var classDeclaration = type.symbol.valueDeclaration;
                 if (ts.getObjectFlags(type) & 1 /* Class */ && classDeclaration && ts.isClassLike(classDeclaration)) {
-                    for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) {
-                        var member = _a[_i];
+                    for (var _i = 0, _e = classDeclaration.members; _i < _e.length; _i++) {
+                        var member = _e[_i];
                         // Only process instance properties with computed names here.
                         // Static properties cannot be in conflict with indexers,
                         // and properties with literal names were already checked.
@@ -78832,7 +78826,7 @@ var ts;
             }
             if (produceDiagnostics) {
                 checkIndexConstraints(type);
-                checkIndexConstraints(staticType);
+                checkIndexConstraints(staticType, /*isStatic*/ true);
                 checkTypeForDuplicateIndexSignatures(node);
                 checkPropertyInitialization(node);
             }
@@ -86101,6 +86095,7 @@ var ts;
                 case 120 /* PrivateKeyword */:
                 case 121 /* ProtectedKeyword */:
                 case 125 /* AbstractKeyword */:
+                case 156 /* OverrideKeyword */:
                 case 84 /* ConstKeyword */:
                 case 133 /* DeclareKeyword */:
                 case 142 /* ReadonlyKeyword */:
@@ -88891,10 +88886,11 @@ var ts;
                 return ts.visitEachChild(node, visitor, context);
             }
             var staticProperties = ts.getProperties(node, /*requireInitializer*/ false, /*isStatic*/ true);
+            var pendingPrivateStateAssignment;
             if (shouldTransformPrivateElements && ts.some(node.members, function (m) { return ts.hasStaticModifier(m) && !!m.name && ts.isPrivateIdentifier(m.name); })) {
                 var temp = factory.createTempVariable(hoistVariableDeclaration, /* reservedInNestedScopes */ true);
                 getPrivateIdentifierEnvironment().classConstructor = factory.cloneNode(temp);
-                getPendingExpressions().push(factory.createAssignment(temp, factory.getInternalName(node)));
+                pendingPrivateStateAssignment = factory.createAssignment(temp, factory.getInternalName(node));
             }
             var extendsClauseElement = ts.getEffectiveBaseTypeNode(node);
             var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 103 /* NullKeyword */);
@@ -88903,6 +88899,9 @@ var ts;
                 /*decorators*/ undefined, node.modifiers, node.name, 
                 /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass))
             ];
+            if (pendingPrivateStateAssignment) {
+                getPendingExpressions().unshift(pendingPrivateStateAssignment);
+            }
             // Write any pending expressions from elided or moved computed property names
             if (ts.some(pendingExpressions)) {
                 statements.push(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions)));
@@ -107289,11 +107288,21 @@ var ts;
                     // JsxText will be written with its leading whitespace, so don't add more manually.
                     return 0;
                 }
-                else if (preserveSourceNewlines && siblingNodePositionsAreComparable(previousNode, nextNode)) {
-                    return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenRangeEndAndRangeStart(previousNode, nextNode, currentSourceFile, includeComments); });
-                }
-                else if (!preserveSourceNewlines && !ts.nodeIsSynthesized(previousNode) && !ts.nodeIsSynthesized(nextNode)) {
-                    return ts.rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile) ? 0 : 1;
+                else if (!ts.nodeIsSynthesized(previousNode) && !ts.nodeIsSynthesized(nextNode)) {
+                    if (preserveSourceNewlines && siblingNodePositionsAreComparable(previousNode, nextNode)) {
+                        return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenRangeEndAndRangeStart(previousNode, nextNode, currentSourceFile, includeComments); });
+                    }
+                    // If `preserveSourceNewlines` is `false` we do not intend to preserve the effective lines between the
+                    // previous and next node. Instead we naively check whether nodes are on separate lines within the
+                    // same node parent. If so, we intend to preserve a single line terminator. This is less precise and
+                    // expensive than checking with `preserveSourceNewlines` as above, but the goal is not to preserve the
+                    // effective source lines between two sibling nodes.
+                    else if (!preserveSourceNewlines && originalNodesHaveSameParent(previousNode, nextNode)) {
+                        return ts.rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile) ? 0 : 1;
+                    }
+                    // If the two nodes are not comparable, add a line terminator based on the format that can indicate
+                    // whether new lines are preferred or not.
+                    return format & 65536 /* PreferNewLine */ ? 1 : 0;
                 }
                 else if (synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format)) {
                     return 1;
@@ -107933,10 +107942,13 @@ var ts;
             }
             exitComment();
         }
+        function originalNodesHaveSameParent(nodeA, nodeB) {
+            nodeA = ts.getOriginalNode(nodeA);
+            // For performance, do not call `getOriginalNode` for `nodeB` if `nodeA` doesn't even
+            // have a parent node.
+            return nodeA.parent && nodeA.parent === ts.getOriginalNode(nodeB).parent;
+        }
         function siblingNodePositionsAreComparable(previousNode, nextNode) {
-            if (ts.nodeIsSynthesized(previousNode) || ts.nodeIsSynthesized(nextNode)) {
-                return false;
-            }
             if (nextNode.pos < previousNode.end) {
                 return false;
             }
@@ -113309,8 +113321,14 @@ var ts;
         var optionsNameMap = ts.getOptionsNameMap().optionsNameMap;
         for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) {
             var name = _a[_i];
-            var optionInfo = optionsNameMap.get(name.toLowerCase());
-            if ((optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsEmit) || (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsSemanticDiagnostics) || name === "skipLibCheck" || name === "skipDefaultLibCheck") {
+            var optionKey = name.toLowerCase();
+            var optionInfo = optionsNameMap.get(optionKey);
+            if ((optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsEmit) || (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsSemanticDiagnostics) ||
+                // We need to store `strict`, even though it won't be examined directly, so that the
+                // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly from the buildinfo
+                optionKey === "strict" ||
+                // We need to store these to determine whether `lib` files need to be rechecked.
+                optionKey === "skiplibcheck" || optionKey === "skipdefaultlibcheck") {
                 (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfo);
             }
         }
@@ -116819,7 +116837,7 @@ var ts;
                 },
                 emit: function (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
                     if (targetSourceFile || emitOnlyDtsFiles) {
-                        return withProgramOrUndefined(function (program) { return program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers); });
+                        return withProgramOrUndefined(function (program) { var _a, _b; return program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers || ((_b = (_a = state.host).getCustomTransformers) === null || _b === void 0 ? void 0 : _b.call(_a, project))); });
                     }
                     executeSteps(BuildStep.SemanticDiagnostics, cancellationToken);
                     if (step === BuildStep.EmitBuildInfo) {
@@ -116904,6 +116922,7 @@ var ts;
         }
         function emit(writeFileCallback, cancellationToken, customTransformers) {
             var _a;
+            var _b, _c;
             ts.Debug.assertIsDefined(program);
             ts.Debug.assert(step === BuildStep.Emit);
             // Before emitting lets backup state, so we can revert it back if there are declaration errors to handle emit and declaration errors correctly
@@ -116914,7 +116933,7 @@ var ts;
             var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, 
             /*write*/ undefined, 
             /*reportSummary*/ undefined, function (name, text, writeByteOrderMark) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, cancellationToken, 
-            /*emitOnlyDts*/ false, customTransformers).emitResult;
+            /*emitOnlyDts*/ false, customTransformers || ((_c = (_b = state.host).getCustomTransformers) === null || _c === void 0 ? void 0 : _c.call(_b, project))).emitResult;
             // Don't emit .d.ts if there are decl file errors
             if (declDiagnostics) {
                 program.restoreState();
@@ -116996,6 +117015,7 @@ var ts;
             return emitDiagnostics;
         }
         function emitBundle(writeFileCallback, customTransformers) {
+            var _a, _b;
             ts.Debug.assert(kind === InvalidatedProjectKind.UpdateBundle);
             if (state.options.dry) {
                 reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_output_of_project_0, project);
@@ -117011,7 +117031,7 @@ var ts;
             var outputFiles = ts.emitUsingBuildInfo(config, compilerHost, function (ref) {
                 var refName = resolveProjectName(state, ref.path);
                 return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName));
-            }, customTransformers);
+            }, customTransformers || ((_b = (_a = state.host).getCustomTransformers) === null || _b === void 0 ? void 0 : _b.call(_a, project)));
             if (ts.isString(outputFiles)) {
                 reportStatus(state, ts.Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles));
                 step = BuildStep.BuildInvalidatedProjectOfBundle;
@@ -121279,9 +121299,7 @@ var ts;
             [8 /* OptionalDependencies */, info.optionalDependencies],
             [4 /* PeerDependencies */, info.peerDependencies],
         ];
-        return __assign(__assign({}, info), { parseable: !!content, fileName: fileName,
-            get: get,
-            has: function (dependencyName, inGroups) {
+        return __assign(__assign({}, info), { parseable: !!content, fileName: fileName, get: get, has: function (dependencyName, inGroups) {
                 return !!get(dependencyName, inGroups);
             } });
         function get(dependencyName, inGroups) {
@@ -123737,6 +123755,8 @@ var ts;
                     return jsdocCompletionInfo(ts.JsDoc.getJSDocTagCompletions());
                 case 3 /* JsDocParameterName */:
                     return jsdocCompletionInfo(ts.JsDoc.getJSDocParameterNameCompletions(completionData.tag));
+                case 4 /* Keywords */:
+                    return specificKeywordCompletionInfo(completionData.keywords);
                 default:
                     return ts.Debug.assertNever(completionData);
             }
@@ -123745,6 +123765,19 @@ var ts;
         function jsdocCompletionInfo(entries) {
             return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: entries };
         }
+        function specificKeywordCompletionInfo(keywords) {
+            return {
+                isGlobalCompletion: false,
+                isMemberCompletion: false,
+                isNewIdentifierLocation: false,
+                entries: keywords.map(function (k) { return ({
+                    name: ts.tokenToString(k),
+                    kind: "keyword" /* keyword */,
+                    kindModifiers: "" /* none */,
+                    sortText: SortText.GlobalsOrKeywords,
+                }); }),
+            };
+        }
         function getOptionalReplacementSpan(location) {
             // StringLiteralLike locations are handled separately in stringCompletions.ts
             return (location === null || location === void 0 ? void 0 : location.kind) === 78 /* Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
@@ -124169,6 +124202,8 @@ var ts;
                             return ts.JsDoc.getJSDocTagCompletionDetails(name);
                         case 3 /* JsDocParameterName */:
                             return ts.JsDoc.getJSDocParameterNameCompletionDetails(name);
+                        case 4 /* Keywords */:
+                            return request.keywords.indexOf(ts.stringToToken(name)) > -1 ? createSimpleDetails(name, "keyword" /* keyword */, ts.SymbolDisplayPartKind.keyword) : undefined;
                         default:
                             return ts.Debug.assertNever(request);
                     }
@@ -124227,6 +124262,7 @@ var ts;
             CompletionDataKind[CompletionDataKind["JsDocTagName"] = 1] = "JsDocTagName";
             CompletionDataKind[CompletionDataKind["JsDocTag"] = 2] = "JsDocTag";
             CompletionDataKind[CompletionDataKind["JsDocParameterName"] = 3] = "JsDocParameterName";
+            CompletionDataKind[CompletionDataKind["Keywords"] = 4] = "Keywords";
         })(CompletionDataKind || (CompletionDataKind = {}));
         var CompletionKind;
         (function (CompletionKind) {
@@ -124387,13 +124423,17 @@ var ts;
             var importCompletionNode;
             var location = ts.getTouchingPropertyName(sourceFile, position);
             if (contextToken) {
+                var importCompletionCandidate = getImportCompletionNode(contextToken);
+                if (importCompletionCandidate === 153 /* FromKeyword */) {
+                    return { kind: 4 /* Keywords */, keywords: [153 /* FromKeyword */] };
+                }
                 // Import statement completions use `insertText`, and also require the `data` property of `CompletionEntryIdentifier`
                 // added in TypeScript 4.3 to be sent back from the client during `getCompletionEntryDetails`. Since this feature
                 // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients
                 // to opt in with the `includeCompletionsForImportStatements` user preference.
-                importCompletionNode = preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText
-                    ? getImportCompletionNode(contextToken)
-                    : undefined;
+                if (importCompletionCandidate && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
+                    importCompletionNode = importCompletionCandidate;
+                }
                 // Bail out if this is a known invalid completion location
                 if (!importCompletionNode && isCompletionListBlocker(contextToken)) {
                     log("Returning an empty list because completion was requested in an invalid position.");
@@ -126147,16 +126187,20 @@ var ts;
         }
         function getImportCompletionNode(contextToken) {
             var candidate = getCandidate();
-            return candidate && ts.rangeIsOnSingleLine(candidate, candidate.getSourceFile()) ? candidate : undefined;
+            return candidate === 153 /* FromKeyword */ || candidate && ts.rangeIsOnSingleLine(candidate, candidate.getSourceFile()) ? candidate : undefined;
             function getCandidate() {
                 var parent = contextToken.parent;
                 if (ts.isImportEqualsDeclaration(parent)) {
                     return isModuleSpecifierMissingOrEmpty(parent.moduleReference) ? parent : undefined;
                 }
                 if (ts.isNamedImports(parent) || ts.isNamespaceImport(parent)) {
-                    return isModuleSpecifierMissingOrEmpty(parent.parent.parent.moduleSpecifier) && (ts.isNamespaceImport(parent) || parent.elements.length < 2) && !parent.parent.name
-                        ? parent.parent.parent
-                        : undefined;
+                    if (isModuleSpecifierMissingOrEmpty(parent.parent.parent.moduleSpecifier) && (ts.isNamespaceImport(parent) || parent.elements.length < 2) && !parent.parent.name) {
+                        // At `import { ... } |` or `import * as Foo |`, the only possible completion is `from`
+                        return contextToken.kind === 19 /* CloseBraceToken */ || contextToken.kind === 78 /* Identifier */
+                            ? 153 /* FromKeyword */
+                            : parent.parent.parent;
+                    }
+                    return undefined;
                 }
                 if (ts.isImportKeyword(contextToken) && ts.isSourceFile(parent)) {
                     // A lone import keyword with nothing following it does not parse as a statement at all
@@ -127681,9 +127725,7 @@ var ts;
                         var name_1 = displayParts_1.map(function (p) { return p.text; }).join("");
                         var declaration = symbol.declarations && ts.firstOrUndefined(symbol.declarations);
                         var node = declaration ? (ts.getNameOfDeclaration(declaration) || declaration) : originalNode;
-                        return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: name_1,
-                            kind: kind_1,
-                            displayParts: displayParts_1, context: getContextNode(declaration) });
+                        return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: name_1, kind: kind_1, displayParts: displayParts_1, context: getContextNode(declaration) });
                     }
                     case 1 /* Label */: {
                         var node = def.node;
@@ -127718,10 +127760,7 @@ var ts;
                 }
             })();
             var sourceFile = info.sourceFile, textSpan = info.textSpan, name = info.name, kind = info.kind, displayParts = info.displayParts, context = info.context;
-            return __assign({ containerKind: "" /* unknown */, containerName: "", fileName: sourceFile.fileName, kind: kind,
-                name: name,
-                textSpan: textSpan,
-                displayParts: displayParts }, toContextSpan(textSpan, sourceFile, context));
+            return __assign({ containerKind: "" /* unknown */, containerName: "", fileName: sourceFile.fileName, kind: kind, name: name, textSpan: textSpan, displayParts: displayParts }, toContextSpan(textSpan, sourceFile, context));
         }
         function getFileAndTextSpanFromNode(node) {
             var sourceFile = node.getSourceFile();
@@ -148140,8 +148179,10 @@ var ts;
                 }
                 if (context.preferences.provideRefactorNotApplicableReason) {
                     return [
-                        { name: refactorName, description: namespaceToNamedAction.description, actions: [__assign(__assign({}, namespaceToNamedAction), { notApplicableReason: info.error })] },
-                        { name: refactorName, description: namedToNamespaceAction.description, actions: [__assign(__assign({}, namedToNamespaceAction), { notApplicableReason: info.error })] }
+                        { name: refactorName, description: namespaceToNamedAction.description,
+                            actions: [__assign(__assign({}, namespaceToNamedAction), { notApplicableReason: info.error })] },
+                        { name: refactorName, description: namedToNamespaceAction.description,
+                            actions: [__assign(__assign({}, namedToNamespaceAction), { notApplicableReason: info.error })] }
                     ];
                 }
                 return ts.emptyArray;