typescript 4.6.0-dev.20220104 → 4.6.0-dev.20220108

package/lib/tsserverlibrary.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220104";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220108";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -14650,7 +14650,8 @@ var ts;
                 Float64Array: ["at"],
                 BigInt64Array: ["at"],
                 BigUint64Array: ["at"],
-                ObjectConstructor: ["hasOwn"]
+                ObjectConstructor: ["hasOwn"],
+                Error: ["cause"]
             }
         };
     }
@@ -20961,9 +20962,40 @@ var ts;
     }
     ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
     function escapeSnippetText(text) {
-        return text.replace(/\$/gm, "\\$");
+        return text.replace(/\$/gm, function () { return "\\$"; });
     }
     ts.escapeSnippetText = escapeSnippetText;
+    function isNumericLiteralName(name) {
+        // The intent of numeric names is that
+        //     - they are names with text in a numeric form, and that
+        //     - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit',
+        //         acquired by applying the abstract 'ToNumber' operation on the name's text.
+        //
+        // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name.
+        // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold.
+        //
+        // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)'
+        // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'.
+        // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names
+        // because their 'ToString' representation is not equal to their original text.
+        // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1.
+        //
+        // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'.
+        // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation.
+        // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number.
+        //
+        // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional.
+        // This is desired behavior, because when indexing with them as numeric entities, you are indexing
+        // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively.
+        return (+name).toString() === name;
+    }
+    ts.isNumericLiteralName = isNumericLiteralName;
+    function createPropertyNameNodeForIdentifierOrLiteral(name, target, singleQuote, stringNamed) {
+        return ts.isIdentifierText(name, target) ? ts.factory.createIdentifier(name) :
+            !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) :
+                ts.factory.createStringLiteral(name, !!singleQuote);
+    }
+    ts.createPropertyNameNodeForIdentifierOrLiteral = createPropertyNameNodeForIdentifierOrLiteral;
     function isThisTypeParameter(type) {
         return !!(type.flags & 262144 /* TypeParameter */ && type.isThisType);
     }
@@ -22436,7 +22468,7 @@ var ts;
                 result.push(createModifier(144 /* ReadonlyKeyword */));
             if (flags & 256 /* Async */)
                 result.push(createModifier(131 /* AsyncKeyword */));
-            return result;
+            return result.length ? result : undefined;
         }
         //
         // Names
@@ -26393,32 +26425,36 @@ var ts;
         }
         function updateModifiers(node, modifiers) {
             var _a;
+            var modifierArray;
             if (typeof modifiers === "number") {
-                modifiers = createModifiersFromModifierFlags(modifiers);
-            }
-            return ts.isParameter(node) ? updateParameterDeclaration(node, node.decorators, modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) :
-                ts.isPropertySignature(node) ? updatePropertySignature(node, modifiers, node.name, node.questionToken, node.type) :
-                    ts.isPropertyDeclaration(node) ? updatePropertyDeclaration(node, node.decorators, modifiers, node.name, (_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, node.type, node.initializer) :
-                        ts.isMethodSignature(node) ? updateMethodSignature(node, modifiers, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) :
-                            ts.isMethodDeclaration(node) ? updateMethodDeclaration(node, node.decorators, modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) :
-                                ts.isConstructorDeclaration(node) ? updateConstructorDeclaration(node, node.decorators, modifiers, node.parameters, node.body) :
-                                    ts.isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, node.decorators, modifiers, node.name, node.parameters, node.type, node.body) :
-                                        ts.isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, node.decorators, modifiers, node.name, node.parameters, node.body) :
-                                            ts.isIndexSignatureDeclaration(node) ? updateIndexSignature(node, node.decorators, modifiers, node.parameters, node.type) :
-                                                ts.isFunctionExpression(node) ? updateFunctionExpression(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
-                                                    ts.isArrowFunction(node) ? updateArrowFunction(node, modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) :
-                                                        ts.isClassExpression(node) ? updateClassExpression(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
-                                                            ts.isVariableStatement(node) ? updateVariableStatement(node, modifiers, node.declarationList) :
-                                                                ts.isFunctionDeclaration(node) ? updateFunctionDeclaration(node, node.decorators, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
-                                                                    ts.isClassDeclaration(node) ? updateClassDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
-                                                                        ts.isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
-                                                                            ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.type) :
-                                                                                ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifiers, node.name, node.members) :
-                                                                                    ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifiers, node.name, node.body) :
-                                                                                        ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.name, node.moduleReference) :
-                                                                                            ts.isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifiers, node.importClause, node.moduleSpecifier, node.assertClause) :
-                                                                                                ts.isExportAssignment(node) ? updateExportAssignment(node, node.decorators, modifiers, node.expression) :
-                                                                                                    ts.isExportDeclaration(node) ? updateExportDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) :
+                modifierArray = createModifiersFromModifierFlags(modifiers);
+            }
+            else {
+                modifierArray = modifiers;
+            }
+            return ts.isParameter(node) ? updateParameterDeclaration(node, node.decorators, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) :
+                ts.isPropertySignature(node) ? updatePropertySignature(node, modifierArray, node.name, node.questionToken, node.type) :
+                    ts.isPropertyDeclaration(node) ? updatePropertyDeclaration(node, node.decorators, modifierArray, node.name, (_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, node.type, node.initializer) :
+                        ts.isMethodSignature(node) ? updateMethodSignature(node, modifierArray, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) :
+                            ts.isMethodDeclaration(node) ? updateMethodDeclaration(node, node.decorators, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) :
+                                ts.isConstructorDeclaration(node) ? updateConstructorDeclaration(node, node.decorators, modifierArray, node.parameters, node.body) :
+                                    ts.isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, node.decorators, modifierArray, node.name, node.parameters, node.type, node.body) :
+                                        ts.isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, node.decorators, modifierArray, node.name, node.parameters, node.body) :
+                                            ts.isIndexSignatureDeclaration(node) ? updateIndexSignature(node, node.decorators, modifierArray, node.parameters, node.type) :
+                                                ts.isFunctionExpression(node) ? updateFunctionExpression(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
+                                                    ts.isArrowFunction(node) ? updateArrowFunction(node, modifierArray, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) :
+                                                        ts.isClassExpression(node) ? updateClassExpression(node, node.decorators, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) :
+                                                            ts.isVariableStatement(node) ? updateVariableStatement(node, modifierArray, node.declarationList) :
+                                                                ts.isFunctionDeclaration(node) ? updateFunctionDeclaration(node, node.decorators, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
+                                                                    ts.isClassDeclaration(node) ? updateClassDeclaration(node, node.decorators, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) :
+                                                                        ts.isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, node.decorators, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) :
+                                                                            ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifierArray, node.name, node.typeParameters, node.type) :
+                                                                                ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifierArray, node.name, node.members) :
+                                                                                    ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifierArray, node.name, node.body) :
+                                                                                        ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifierArray, node.isTypeOnly, node.name, node.moduleReference) :
+                                                                                            ts.isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifierArray, node.importClause, node.moduleSpecifier, node.assertClause) :
+                                                                                                ts.isExportAssignment(node) ? updateExportAssignment(node, node.decorators, modifierArray, node.expression) :
+                                                                                                    ts.isExportDeclaration(node) ? updateExportDeclaration(node, node.decorators, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) :
                                                                                                         ts.Debug.assertNever(node);
         }
         function asNodeArray(array) {
@@ -47032,6 +47068,7 @@ var ts;
                 var location = ts.getParseTreeNode(locationIn);
                 return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType;
             },
+            getTypeOfSymbol: getTypeOfSymbol,
             getSymbolsOfParameterPropertyDeclaration: function (parameterIn, parameterName) {
                 var parameter = ts.getParseTreeNode(parameterIn, ts.isParameter);
                 if (parameter === undefined)
@@ -52387,7 +52424,7 @@ var ts;
                 }
                 var rawName = ts.unescapeLeadingUnderscores(symbol.escapedName);
                 var stringNamed = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isStringNamed);
-                return createPropertyNameNodeForIdentifierOrLiteral(rawName, stringNamed, singleQuote);
+                return ts.createPropertyNameNodeForIdentifierOrLiteral(rawName, ts.getEmitScriptTarget(compilerOptions), singleQuote, stringNamed);
             }
             // See getNameForSymbolFromNameType for a stringy equivalent
             function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote) {
@@ -52395,24 +52432,19 @@ var ts;
                 if (nameType) {
                     if (nameType.flags & 384 /* StringOrNumberLiteral */) {
                         var name = "" + nameType.value;
-                        if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
+                        if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) {
                             return ts.factory.createStringLiteral(name, !!singleQuote);
                         }
-                        if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
+                        if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) {
                             return ts.factory.createComputedPropertyName(ts.factory.createNumericLiteral(+name));
                         }
-                        return createPropertyNameNodeForIdentifierOrLiteral(name);
+                        return ts.createPropertyNameNodeForIdentifierOrLiteral(name, ts.getEmitScriptTarget(compilerOptions));
                     }
                     if (nameType.flags & 8192 /* UniqueESSymbol */) {
                         return ts.factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551 /* Value */));
                     }
                 }
             }
-            function createPropertyNameNodeForIdentifierOrLiteral(name, stringNamed, singleQuote) {
-                return ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) ? ts.factory.createIdentifier(name) :
-                    !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) :
-                        ts.factory.createStringLiteral(name, !!singleQuote);
-            }
             function cloneNodeBuilderContext(context) {
                 var initial = __assign({}, context);
                 // Make type parameters created within this context not consume the name outside this context
@@ -53928,10 +53960,10 @@ var ts;
             if (nameType) {
                 if (nameType.flags & 384 /* StringOrNumberLiteral */) {
                     var name = "" + nameType.value;
-                    if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
+                    if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) {
                         return "\"" + ts.escapeString(name, 34 /* doubleQuote */) + "\"";
                     }
-                    if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
+                    if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) {
                         return "[" + name + "]";
                     }
                     return name;
@@ -57974,7 +58006,7 @@ var ts;
             // signature applies to types assignable to 'number' and numeric string literal types.
             return isTypeAssignableTo(source, target) ||
                 target === stringType && isTypeAssignableTo(source, numberType) ||
-                target === numberType && !!(source.flags & 128 /* StringLiteral */) && isNumericLiteralName(source.value);
+                target === numberType && !!(source.flags & 128 /* StringLiteral */) && ts.isNumericLiteralName(source.value);
         }
         function getIndexInfosOfStructuredType(type) {
             if (type.flags & 3670016 /* StructuredType */) {
@@ -60540,7 +60572,7 @@ var ts;
                         getFlowTypeOfReference(accessExpression, propType) :
                         propType;
                 }
-                if (everyType(objectType, isTupleType) && isNumericLiteralName(propName) && +propName >= 0) {
+                if (everyType(objectType, isTupleType) && ts.isNumericLiteralName(propName) && +propName >= 0) {
                     if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 16 /* NoTupleBoundsCheck */)) {
                         var indexNode = getIndexNodeForAccessExpression(accessNode);
                         if (isTupleType(objectType)) {
@@ -60825,7 +60857,7 @@ var ts;
             return everyType(indexType, function (t) {
                 if (t.flags & 384 /* StringOrNumberLiteral */) {
                     var propName = getPropertyNameFromType(t);
-                    if (isNumericLiteralName(propName)) {
+                    if (ts.isNumericLiteralName(propName)) {
                         var index = +propName;
                         return index >= 0 && index < limit;
                     }
@@ -64367,7 +64399,7 @@ var ts;
                     else {
                         // conditionals aren't related to one another via distributive constraint as it is much too inaccurate and allows way
                         // more assignments than are desirable (since it maps the source check type to its constraint, it loses information)
-                        var distributiveConstraint = getConstraintOfDistributiveConditionalType(source);
+                        var distributiveConstraint = hasNonCircularBaseConstraint(source) ? getConstraintOfDistributiveConditionalType(source) : undefined;
                         if (distributiveConstraint) {
                             if (result = isRelatedTo(distributiveConstraint, target, 1 /* Source */, reportErrors)) {
                                 resetErrorInfo(saveErrorInfo);
@@ -64913,7 +64945,7 @@ var ts;
                 for (var _b = 0, _c = excludeProperties(properties, excludedProperties); _b < _c.length; _b++) {
                     var targetProp = _c[_b];
                     var name = targetProp.escapedName;
-                    if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
+                    if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || ts.isNumericLiteralName(name) || name === "length")) {
                         var sourceProp = getPropertyOfType(source, name);
                         if (sourceProp && sourceProp !== targetProp) {
                             var related = propertyRelatedTo(source, target, sourceProp, targetProp, getNonMissingTypeOfSymbol, reportErrors, intersectionState, relation === comparableRelation);
@@ -64986,7 +65018,8 @@ var ts;
                 var incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
                 var sourceObjectFlags = ts.getObjectFlags(source);
                 var targetObjectFlags = ts.getObjectFlags(target);
-                if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source.symbol === target.symbol) {
+                if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source.symbol === target.symbol ||
+                    sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source.target === target.target) {
                     // We have instantiations of the same anonymous type (which typically will be the type of a
                     // method). Simply do a pairwise comparison of the signatures in the two signature lists instead
                     // of the much more expensive N * M comparison matrix we explore below. We erase type parameters
@@ -66021,9 +66054,12 @@ var ts;
          * with no call or construct signatures.
          */
         function isObjectTypeWithInferableIndex(type) {
-            return type.flags & 2097152 /* Intersection */ ? ts.every(type.types, isObjectTypeWithInferableIndex) :
-                !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 &&
-                    !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
+            return type.flags & 2097152 /* Intersection */
+                ? ts.every(type.types, isObjectTypeWithInferableIndex)
+                : !!(type.symbol
+                    && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0
+                    && !(type.symbol.flags & 32 /* Class */)
+                    && !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
         }
         function createSymbolWithType(source, type) {
             var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8 /* Readonly */);
@@ -67631,7 +67667,8 @@ var ts;
             return access.kind === 205 /* PropertyAccessExpression */ ? access.name.escapedText :
                 access.kind === 206 /* ElementAccessExpression */ && ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) :
                     access.kind === 202 /* BindingElement */ && (propertyName = getDestructuringPropertyName(access)) ? ts.escapeLeadingUnderscores(propertyName) :
-                        undefined;
+                        access.kind === 163 /* Parameter */ ? ("" + access.parent.parameters.indexOf(access)) :
+                            undefined;
         }
         function containsMatchingReference(source, target) {
             while (ts.isAccessExpression(source)) {
@@ -68971,13 +69008,14 @@ var ts;
                 return result;
             }
             function getCandidateDiscriminantPropertyAccess(expr) {
-                if (ts.isBindingPattern(reference)) {
-                    // When the reference is a binding pattern, we are narrowing a pesudo-reference in getNarrowedTypeOfSymbol.
-                    // An identifier for a destructuring variable declared in the same binding pattern is a candidate.
+                if (ts.isBindingPattern(reference) || ts.isFunctionExpressionOrArrowFunction(reference)) {
+                    // When the reference is a binding pattern or function or arrow expression, we are narrowing a pesudo-reference in
+                    // getNarrowedTypeOfSymbol. An identifier for a destructuring variable declared in the same binding pattern or
+                    // parameter declared in the same parameter list is a candidate.
                     if (ts.isIdentifier(expr)) {
                         var symbol = getResolvedSymbol(expr);
                         var declaration = symbol.valueDeclaration;
-                        if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
+                        if (declaration && (ts.isBindingElement(declaration) || ts.isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
                             return declaration;
                         }
                     }
@@ -69779,42 +69817,78 @@ var ts;
             }
         }
         function getNarrowedTypeOfSymbol(symbol, location) {
-            // If we have a non-rest binding element with no initializer declared as a const variable or a const-like
-            // parameter (a parameter for which there are no assignments in the function body), and if the parent type
-            // for the destructuring is a union type, one or more of the binding elements may represent discriminant
-            // properties, and we want the effects of conditional checks on such discriminants to affect the types of
-            // other binding elements from the same destructuring. Consider:
-            //
-            //   type Action =
-            //       | { kind: 'A', payload: number }
-            //       | { kind: 'B', payload: string };
-            //
-            //   function f1({ kind, payload }: Action) {
-            //       if (kind === 'A') {
-            //           payload.toFixed();
-            //       }
-            //       if (kind === 'B') {
-            //           payload.toUpperCase();
-            //       }
-            //   }
-            //
-            // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
-            // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
-            // as if it occurred in the specified location. We then recompute the narrowed binding element type by
-            // destructuring from the narrowed parent type.
             var declaration = symbol.valueDeclaration;
-            if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
-                var parent = declaration.parent.parent;
-                if (parent.kind === 253 /* VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 163 /* Parameter */) {
-                    var links = getNodeLinks(location);
-                    if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
-                        links.flags |= 268435456 /* InCheckIdentifier */;
-                        var parentType = getTypeForBindingElementParent(parent);
-                        links.flags &= ~268435456 /* InCheckIdentifier */;
-                        if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
-                            var pattern = declaration.parent;
-                            var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
-                            return getBindingElementTypeFromParentType(declaration, narrowedType);
+            if (declaration) {
+                // If we have a non-rest binding element with no initializer declared as a const variable or a const-like
+                // parameter (a parameter for which there are no assignments in the function body), and if the parent type
+                // for the destructuring is a union type, one or more of the binding elements may represent discriminant
+                // properties, and we want the effects of conditional checks on such discriminants to affect the types of
+                // other binding elements from the same destructuring. Consider:
+                //
+                //   type Action =
+                //       | { kind: 'A', payload: number }
+                //       | { kind: 'B', payload: string };
+                //
+                //   function f({ kind, payload }: Action) {
+                //       if (kind === 'A') {
+                //           payload.toFixed();
+                //       }
+                //       if (kind === 'B') {
+                //           payload.toUpperCase();
+                //       }
+                //   }
+                //
+                // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
+                // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
+                // as if it occurred in the specified location. We then recompute the narrowed binding element type by
+                // destructuring from the narrowed parent type.
+                if (ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
+                    var parent = declaration.parent.parent;
+                    if (parent.kind === 253 /* VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 163 /* Parameter */) {
+                        var links = getNodeLinks(location);
+                        if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
+                            links.flags |= 268435456 /* InCheckIdentifier */;
+                            var parentType = getTypeForBindingElementParent(parent);
+                            links.flags &= ~268435456 /* InCheckIdentifier */;
+                            if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
+                                var pattern = declaration.parent;
+                                var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
+                                return getBindingElementTypeFromParentType(declaration, narrowedType);
+                            }
+                        }
+                    }
+                }
+                // If we have a const-like parameter with no type annotation or initializer, and if the parameter is contextually
+                // typed by a signature with a single rest parameter of a union of tuple types, one or more of the parameters may
+                // represent discriminant tuple elements, and we want the effects of conditional checks on such discriminants to
+                // affect the types of other parameters in the same parameter list. Consider:
+                //
+                //   type Action = [kind: 'A', payload: number] | [kind: 'B', payload: string];
+                //
+                //   const f: (...args: Action) => void = (kind, payload) => {
+                //       if (kind === 'A') {
+                //           payload.toFixed();
+                //       }
+                //       if (kind === 'B') {
+                //           payload.toUpperCase();
+                //       }
+                //   }
+                //
+                // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
+                // the arrow function AST node for '(kind, payload) => ...' as a pseudo-reference and narrow this reference as
+                // if it occurred in the specified location. We then recompute the narrowed parameter type by indexing into the
+                // narrowed tuple type.
+                if (ts.isParameter(declaration) && !declaration.type && !declaration.initializer && !declaration.dotDotDotToken) {
+                    var func = declaration.parent;
+                    if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
+                        var contextualSignature = getContextualSignature(func);
+                        if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) {
+                            var restType = getTypeOfSymbol(contextualSignature.parameters[0]);
+                            if (restType.flags & 1048576 /* Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) {
+                                var narrowedType = getFlowTypeOfReference(func, restType, restType, /*flowContainer*/ undefined, location.flowNode);
+                                var index = func.parameters.indexOf(declaration) - (ts.getThisParameter(func) ? 1 : 0);
+                                return getIndexedAccessType(narrowedType, getNumberLiteralType(index));
+                            }
                         }
                     }
                 }
@@ -70955,7 +71029,7 @@ var ts;
                     }
                     if (isTupleType(t)) {
                         var restType = getRestTypeOfTupleType(t);
-                        if (restType && isNumericLiteralName(name) && +name >= 0) {
+                        if (restType && ts.isNumericLiteralName(name) && +name >= 0) {
                             return restType;
                         }
                     }
@@ -71596,10 +71670,10 @@ var ts;
                 case 161 /* ComputedPropertyName */:
                     return isNumericComputedName(name);
                 case 79 /* Identifier */:
-                    return isNumericLiteralName(name.escapedText);
+                    return ts.isNumericLiteralName(name.escapedText);
                 case 8 /* NumericLiteral */:
                 case 10 /* StringLiteral */:
-                    return isNumericLiteralName(name.text);
+                    return ts.isNumericLiteralName(name.text);
                 default:
                     return false;
             }
@@ -71609,30 +71683,6 @@ var ts;
             // but this behavior is consistent with checkIndexedAccess
             return isTypeAssignableToKind(checkComputedPropertyName(name), 296 /* NumberLike */);
         }
-        function isNumericLiteralName(name) {
-            // The intent of numeric names is that
-            //     - they are names with text in a numeric form, and that
-            //     - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit',
-            //         acquired by applying the abstract 'ToNumber' operation on the name's text.
-            //
-            // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name.
-            // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold.
-            //
-            // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)'
-            // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'.
-            // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names
-            // because their 'ToString' representation is not equal to their original text.
-            // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1.
-            //
-            // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'.
-            // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation.
-            // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number.
-            //
-            // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional.
-            // This is desired behavior, because when indexing with them as numeric entities, you are indexing
-            // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively.
-            return (+name).toString() === name;
-        }
         function checkComputedPropertyName(node) {
             var links = getNodeLinks(node.expression);
             if (!links.resolvedType) {
@@ -71668,7 +71718,7 @@ var ts;
         function isSymbolWithNumericName(symbol) {
             var _a;
             var firstDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0];
-            return isNumericLiteralName(symbol.escapedName) || (firstDecl && ts.isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name));
+            return ts.isNumericLiteralName(symbol.escapedName) || (firstDecl && ts.isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name));
         }
         function isSymbolWithSymbolName(symbol) {
             var _a;
@@ -82606,7 +82656,7 @@ var ts;
             }
             else {
                 var text = ts.getTextOfPropertyName(member.name);
-                if (isNumericLiteralName(text) && !ts.isInfinityOrNaNString(text)) {
+                if (ts.isNumericLiteralName(text) && !ts.isInfinityOrNaNString(text)) {
                     error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name);
                 }
             }
@@ -109212,7 +109262,7 @@ var ts;
                     emitPlaceholder(hint, node, snippet);
                     break;
                 case 0 /* TabStop */:
-                    emitTabStop(snippet);
+                    emitTabStop(hint, node, snippet);
                     break;
             }
         }
@@ -109222,7 +109272,10 @@ var ts;
             nonEscapingWrite("}"); // `}`
             // `${2:...}`
         }
-        function emitTabStop(snippet) {
+        function emitTabStop(hint, node, snippet) {
+            // A tab stop should only be attached to an empty node, i.e. a node that doesn't emit any text.
+            ts.Debug.assert(node.kind === 235 /* EmptyStatement */, "A tab stop cannot be attached to a node of kind " + ts.Debug.formatSyntaxKind(node.kind) + ".");
+            ts.Debug.assert(hint !== 5 /* EmbeddedStatement */, "A tab stop cannot be attached to an embedded statement.");
             nonEscapingWrite("$" + snippet.order);
         }
         //
@@ -120068,7 +120121,7 @@ var ts;
     }
     ts.getLocaleTimeString = getLocaleTimeString;
     /**
-     * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic
+     * Create a function that reports watch status by writing to the system and handles the formatting of the diagnostic
      */
     function createWatchStatusReporter(system, pretty) {
         return pretty ?
@@ -120129,7 +120182,7 @@ var ts;
             ts.Diagnostics.Found_0_errors_Watching_for_file_changes;
     }
     ts.getWatchErrorSummaryDiagnosticMessage = getWatchErrorSummaryDiagnosticMessage;
-    function getErrorSummaryText(errorCount, filesInError, newLine) {
+    function getErrorSummaryText(errorCount, filesInError, newLine, host) {
         if (errorCount === 0)
             return "";
         var nonNilFiles = filesInError.filter(function (fileInError) { return fileInError !== undefined; });
@@ -120144,10 +120197,10 @@ var ts;
                 distinctFileNamesWithLines.length === 1 ?
                     ts.Diagnostics.Found_0_errors_in_1_file :
                     ts.Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length);
-        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine + (errorCount > 1 ? createTabularErrorsDisplay(nonNilFiles) : "");
+        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine + (errorCount > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "");
     }
     ts.getErrorSummaryText = getErrorSummaryText;
-    function createTabularErrorsDisplay(filesInError) {
+    function createTabularErrorsDisplay(filesInError, host) {
         var distinctFiles = filesInError.filter(function (value, index, self) { return index === self.findIndex(function (file) { return (file === null || file === void 0 ? void 0 : file.fileName) === (value === null || value === void 0 ? void 0 : value.fileName); }); });
         if (distinctFiles.length === 0)
             return "";
@@ -120166,7 +120219,8 @@ var ts;
             var leftPadding = errorCountDigitsLength < leftPaddingGoal ?
                 " ".repeat(leftPaddingGoal - errorCountDigitsLength)
                 : "";
-            tabularData += "" + leftPadding + errorCount + "  " + file.fileName + ":" + file.line + "\n";
+            var relativePath = ts.getRelativePathFromDirectory(host.getCurrentDirectory(), file.fileName, /* ignoreCase */ false);
+            tabularData += "" + leftPadding + errorCount + "  " + relativePath + ":" + file.line + "\n";
         });
         return tabularData;
     }
@@ -120584,7 +120638,7 @@ var ts;
         var system = input.system || ts.sys;
         var host = input.host || (input.host = ts.createIncrementalCompilerHost(input.options, system));
         var builderProgram = ts.createIncrementalProgram(input);
-        var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount, filesInError) { return system.write(getErrorSummaryText(errorCount, filesInError, system.newLine)); } : undefined);
+        var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount, filesInError) { return system.write(getErrorSummaryText(errorCount, filesInError, system.newLine, host)); } : undefined);
         if (input.afterProgramEmitAndDiagnostics)
             input.afterProgramEmitAndDiagnostics(builderProgram);
         return exitStatus;
@@ -123058,14 +123112,8 @@ var ts;
             var possibleSearchDirs = new ts.Set(fileNames.map(ts.getDirectoryPath));
             possibleSearchDirs.add(projectRootPath);
             possibleSearchDirs.forEach(function (searchDir) {
-                var packageJsonPath = ts.combinePaths(searchDir, "package.json");
-                getTypingNamesFromJson(packageJsonPath, filesToWatch);
-                var bowerJsonPath = ts.combinePaths(searchDir, "bower.json");
-                getTypingNamesFromJson(bowerJsonPath, filesToWatch);
-                var bowerComponentsPath = ts.combinePaths(searchDir, "bower_components");
-                getTypingNamesFromPackagesFolder(bowerComponentsPath, filesToWatch);
-                var nodeModulesPath = ts.combinePaths(searchDir, "node_modules");
-                getTypingNamesFromPackagesFolder(nodeModulesPath, filesToWatch);
+                getTypingNames(searchDir, "bower.json", "bower_components", filesToWatch);
+                getTypingNames(searchDir, "package.json", "node_modules", filesToWatch);
             });
             if (!typeAcquisition.disableFilenameBasedTypeAcquisition) {
                 getTypingNamesFromSourceFileNames(fileNames);
@@ -123114,16 +123162,100 @@ var ts;
                 ts.forEach(typingNames, addInferredTyping);
             }
             /**
-             * Get the typing info from common package manager json files like package.json or bower.json
+             * Adds inferred typings from manifest/module pairs (think package.json + node_modules)
+             *
+             * @param projectRootPath is the path to the directory where to look for package.json, bower.json and other typing information
+             * @param manifestName is the name of the manifest (package.json or bower.json)
+             * @param modulesDirName is the directory name for modules (node_modules or bower_components). Should be lowercase!
+             * @param filesToWatch are the files to watch for changes. We will push things into this array.
              */
-            function getTypingNamesFromJson(jsonPath, filesToWatch) {
-                if (!host.fileExists(jsonPath)) {
+            function getTypingNames(projectRootPath, manifestName, modulesDirName, filesToWatch) {
+                // First, we check the manifests themselves. They're not
+                // _required_, but they allow us to do some filtering when dealing
+                // with big flat dep directories.
+                var manifestPath = ts.combinePaths(projectRootPath, manifestName);
+                var manifest;
+                var manifestTypingNames;
+                if (host.fileExists(manifestPath)) {
+                    filesToWatch.push(manifestPath);
+                    manifest = ts.readConfigFile(manifestPath, function (path) { return host.readFile(path); }).config;
+                    manifestTypingNames = ts.flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], ts.getOwnKeys);
+                    addInferredTypings(manifestTypingNames, "Typing names in '" + manifestPath + "' dependencies");
+                }
+                // Now we scan the directories for typing information in
+                // already-installed dependencies (if present). Note that this
+                // step happens regardless of whether a manifest was present,
+                // which is certainly a valid configuration, if an unusual one.
+                var packagesFolderPath = ts.combinePaths(projectRootPath, modulesDirName);
+                filesToWatch.push(packagesFolderPath);
+                if (!host.directoryExists(packagesFolderPath)) {
                     return;
                 }
-                filesToWatch.push(jsonPath);
-                var jsonConfig = ts.readConfigFile(jsonPath, function (path) { return host.readFile(path); }).config;
-                var jsonTypingNames = ts.flatMap([jsonConfig.dependencies, jsonConfig.devDependencies, jsonConfig.optionalDependencies, jsonConfig.peerDependencies], ts.getOwnKeys);
-                addInferredTypings(jsonTypingNames, "Typing names in '" + jsonPath + "' dependencies");
+                // There's two cases we have to take into account here:
+                // 1. If manifest is undefined, then we're not using a manifest.
+                //    That means that we should scan _all_ dependencies at the top
+                //    level of the modulesDir.
+                // 2. If manifest is defined, then we can do some special
+                //    filtering to reduce the amount of scanning we need to do.
+                //
+                // Previous versions of this algorithm checked for a `_requiredBy`
+                // field in the package.json, but that field is only present in
+                // `npm@>=3 <7`.
+                // Package names that do **not** provide their own typings, so
+                // we'll look them up.
+                var packageNames = [];
+                var dependencyManifestNames = manifestTypingNames
+                    // This is #1 described above.
+                    ? manifestTypingNames.map(function (typingName) { return ts.combinePaths(packagesFolderPath, typingName, manifestName); })
+                    // And #2. Depth = 3 because scoped packages look like `node_modules/@foo/bar/package.json`
+                    : host.readDirectory(packagesFolderPath, [".json" /* Json */], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 3)
+                        .filter(function (manifestPath) {
+                        if (ts.getBaseFileName(manifestPath) !== manifestName) {
+                            return false;
+                        }
+                        // It's ok to treat
+                        // `node_modules/@foo/bar/package.json` as a manifest,
+                        // but not `node_modules/jquery/nested/package.json`.
+                        // We only assume depth 3 is ok for formally scoped
+                        // packages. So that needs this dance here.
+                        var pathComponents = ts.getPathComponents(ts.normalizePath(manifestPath));
+                        var isScoped = pathComponents[pathComponents.length - 3][0] === "@";
+                        return isScoped && pathComponents[pathComponents.length - 4].toLowerCase() === modulesDirName || // `node_modules/@foo/bar`
+                            !isScoped && pathComponents[pathComponents.length - 3].toLowerCase() === modulesDirName; // `node_modules/foo`
+                    });
+                if (log)
+                    log("Searching for typing names in " + packagesFolderPath + "; all files: " + JSON.stringify(dependencyManifestNames));
+                // Once we have the names of things to look up, we iterate over
+                // and either collect their included typings, or add them to the
+                // list of typings we need to look up separately.
+                for (var _i = 0, dependencyManifestNames_1 = dependencyManifestNames; _i < dependencyManifestNames_1.length; _i++) {
+                    var manifestPath_1 = dependencyManifestNames_1[_i];
+                    var normalizedFileName = ts.normalizePath(manifestPath_1);
+                    var result_1 = ts.readConfigFile(normalizedFileName, function (path) { return host.readFile(path); });
+                    var manifest_1 = result_1.config;
+                    // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used
+                    // to download d.ts files from DefinitelyTyped
+                    if (!manifest_1.name) {
+                        continue;
+                    }
+                    var ownTypes = manifest_1.types || manifest_1.typings;
+                    if (ownTypes) {
+                        var absolutePath = ts.getNormalizedAbsolutePath(ownTypes, ts.getDirectoryPath(normalizedFileName));
+                        if (host.fileExists(absolutePath)) {
+                            if (log)
+                                log("    Package '" + manifest_1.name + "' provides its own types.");
+                            inferredTypings.set(manifest_1.name, absolutePath);
+                        }
+                        else {
+                            if (log)
+                                log("    Package '" + manifest_1.name + "' provides its own types but they are missing.");
+                        }
+                    }
+                    else {
+                        packageNames.push(manifest_1.name);
+                    }
+                }
+                addInferredTypings(packageNames, "    Found package names");
             }
             /**
              * Infer typing names from given file names. For example, the file name "jquery-min.2.3.4.js"
@@ -123149,55 +123281,6 @@ var ts;
                     addInferredTyping("react");
                 }
             }
-            /**
-             * Infer typing names from packages folder (ex: node_module, bower_components)
-             * @param packagesFolderPath is the path to the packages folder
-             */
-            function getTypingNamesFromPackagesFolder(packagesFolderPath, filesToWatch) {
-                filesToWatch.push(packagesFolderPath);
-                // Todo: add support for ModuleResolutionHost too
-                if (!host.directoryExists(packagesFolderPath)) {
-                    return;
-                }
-                // depth of 2, so we access `node_modules/foo` but not `node_modules/foo/bar`
-                var fileNames = host.readDirectory(packagesFolderPath, [".json" /* Json */], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2);
-                if (log)
-                    log("Searching for typing names in " + packagesFolderPath + "; all files: " + JSON.stringify(fileNames));
-                var packageNames = [];
-                for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
-                    var fileName = fileNames_1[_i];
-                    var normalizedFileName = ts.normalizePath(fileName);
-                    var baseFileName = ts.getBaseFileName(normalizedFileName);
-                    if (baseFileName !== "package.json" && baseFileName !== "bower.json") {
-                        continue;
-                    }
-                    var result_1 = ts.readConfigFile(normalizedFileName, function (path) { return host.readFile(path); });
-                    var packageJson = result_1.config;
-                    // npm 3's package.json contains a "_requiredBy" field
-                    // we should include all the top level module names for npm 2, and only module names whose
-                    // "_requiredBy" field starts with "#" or equals "/" for npm 3.
-                    if (baseFileName === "package.json" && packageJson._requiredBy &&
-                        ts.filter(packageJson._requiredBy, function (r) { return r[0] === "#" || r === "/"; }).length === 0) {
-                        continue;
-                    }
-                    // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used
-                    // to download d.ts files from DefinitelyTyped
-                    if (!packageJson.name) {
-                        continue;
-                    }
-                    var ownTypes = packageJson.types || packageJson.typings;
-                    if (ownTypes) {
-                        var absolutePath = ts.getNormalizedAbsolutePath(ownTypes, ts.getDirectoryPath(normalizedFileName));
-                        if (log)
-                            log("    Package '" + packageJson.name + "' provides its own types.");
-                        inferredTypings.set(packageJson.name, absolutePath);
-                    }
-                    else {
-                        packageNames.push(packageJson.name);
-                    }
-                }
-                addInferredTypings(packageNames, "    Found package names");
-            }
         }
         JsTyping.discoverTypings = discoverTypings;
         var NameValidationResult;
@@ -126748,6 +126831,16 @@ var ts;
             : ts.getLocaleSpecificMessage(diag);
     }
     ts.diagnosticToString = diagnosticToString;
+    /**
+     * Get format code settings for a code writing context (e.g. when formatting text changes or completions code).
+     */
+    function getFormatCodeSettingsForWriting(_a, sourceFile) {
+        var options = _a.options;
+        var shouldAutoDetectSemicolonPreference = !options.semicolons || options.semicolons === ts.SemicolonPreference.Ignore;
+        var shouldRemoveSemicolons = options.semicolons === ts.SemicolonPreference.Remove || shouldAutoDetectSemicolonPreference && !probablyUsesSemicolons(sourceFile);
+        return __assign(__assign({}, options), { semicolons: shouldRemoveSemicolons ? ts.SemicolonPreference.Remove : ts.SemicolonPreference.Ignore });
+    }
+    ts.getFormatCodeSettingsForWriting = getFormatCodeSettingsForWriting;
     // #endregion
 })(ts || (ts = {}));
 /*@internal*/
@@ -128371,7 +128464,8 @@ var ts;
                         return convertPathCompletions(completion.paths);
                     case 1 /* Properties */: {
                         var entries = ts.createSortedArray();
-                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, host, program, 99 /* ESNext */, log, 4 /* String */, preferences, options); // Target will not be used, so arbitrary
+                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, host, program, 99 /* ESNext */, log, 4 /* String */, preferences, options, 
+                        /*formatContext*/ undefined); // Target will not be used, so arbitrary
                         return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan: optionalReplacementSpan, entries: entries };
                     }
                     case 2 /* Types */: {
@@ -129192,7 +129286,7 @@ var ts;
                 return result;
             }
         }
-        function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken) {
+        function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext) {
             var _a;
             var previousToken = getRelevantTokens(position, sourceFile).previousToken;
             if (triggerCharacter && !ts.isInString(sourceFile, position, previousToken) && !isValidTrigger(sourceFile, triggerCharacter, previousToken, position)) {
@@ -129232,7 +129326,7 @@ var ts;
             }
             switch (completionData.kind) {
                 case 0 /* Data */:
-                    var response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences);
+                    var response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext);
                     if (response === null || response === void 0 ? void 0 : response.isIncomplete) {
                         incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.set(response);
                     }
@@ -129352,7 +129446,7 @@ var ts;
             // StringLiteralLike locations are handled separately in stringCompletions.ts
             return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
         }
-        function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences) {
+        function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext) {
             var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
             // Verify if the file is JSX language variant
             if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* JSX */) {
@@ -129364,7 +129458,7 @@ var ts;
             var entries = ts.createSortedArray();
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
                 getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries); // TODO: GH#18217
             }
             else {
@@ -129372,7 +129466,7 @@ var ts;
                     return undefined;
                 }
                 getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
             }
             if (keywordFilters !== 0 /* None */) {
                 var entryNames = new ts.Set(entries.map(function (e) { return e.name; }));
@@ -129478,7 +129572,7 @@ var ts;
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
             return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
         }
-        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind) {
+        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind, formatContext) {
             var _a, _b;
             var insertText;
             var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken);
@@ -129543,7 +129637,7 @@ var ts;
                 completionKind === 3 /* MemberLike */ &&
                 isClassLikeMemberCompletion(symbol, location)) {
                 var importAdder = void 0;
-                (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken), insertText = _b.insertText, isSnippet = _b.isSnippet, importAdder = _b.importAdder);
+                (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken, formatContext), insertText = _b.insertText, isSnippet = _b.isSnippet, importAdder = _b.importAdder);
                 if (importAdder === null || importAdder === void 0 ? void 0 : importAdder.hasFixes()) {
                     hasAction = true;
                     source = CompletionSource.ClassMemberSnippet;
@@ -129642,7 +129736,7 @@ var ts;
                         ts.isSyntaxList(location) &&
                         ts.isClassLike(location.parent)));
         }
-        function getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken) {
+        function getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken, formatContext) {
             var classLikeDeclaration = ts.findAncestor(location, ts.isClassLike);
             if (!classLikeDeclaration) {
                 return { insertText: name };
@@ -129659,15 +129753,16 @@ var ts;
                 newLine: ts.getNewLineKind(ts.getNewLineCharacter(options, ts.maybeBind(host, host.getNewLine))),
             });
             var importAdder = ts.codefix.createImportAdder(sourceFile, program, preferences, host);
+            // Create empty body for possible method implementation.
             var body;
             if (preferences.includeCompletionsWithSnippetText) {
                 isSnippet = true;
                 // We are adding a tabstop (i.e. `$0`) in the body of the suggested member,
                 // if it has one, so that the cursor ends up in the body once the completion is inserted.
                 // Note: this assumes we won't have more than one body in the completion nodes, which should be the case.
-                var emptyStatement = ts.factory.createExpressionStatement(ts.factory.createIdentifier(""));
-                ts.setSnippetElement(emptyStatement, { kind: 0 /* TabStop */, order: 0 });
-                body = ts.factory.createBlock([emptyStatement], /* multiline */ true);
+                var emptyStmt = ts.factory.createEmptyStatement();
+                body = ts.factory.createBlock([emptyStmt], /* multiline */ true);
+                ts.setSnippetElement(emptyStmt, { kind: 0 /* TabStop */, order: 0 });
             }
             else {
                 body = ts.factory.createBlock([], /* multiline */ true);
@@ -129713,7 +129808,27 @@ var ts;
                 completionNodes.push(node);
             }, body, 2 /* Property */, isAbstract);
             if (completionNodes.length) {
-                insertText = printer.printSnippetList(1 /* MultiLine */ | 131072 /* NoTrailingNewLine */, ts.factory.createNodeArray(completionNodes), sourceFile);
+                // If we have access to formatting settings, we print the nodes using the emitter,
+                // and then format the printed text.
+                if (formatContext) {
+                    var syntheticFile_1 = {
+                        text: printer.printSnippetList(1 /* MultiLine */ | 131072 /* NoTrailingNewLine */, ts.factory.createNodeArray(completionNodes), sourceFile),
+                        getLineAndCharacterOfPosition: function (pos) {
+                            return ts.getLineAndCharacterOfPosition(this, pos);
+                        },
+                    };
+                    var formatOptions_1 = ts.getFormatCodeSettingsForWriting(formatContext, sourceFile);
+                    var changes = ts.flatMap(completionNodes, function (node) {
+                        var nodeWithPos = ts.textChanges.assignPositionsToNode(node);
+                        return ts.formatting.formatNodeGivenIndentation(nodeWithPos, syntheticFile_1, sourceFile.languageVariant, 
+                        /* indentation */ 0, 
+                        /* delta */ 0, __assign(__assign({}, formatContext), { options: formatOptions_1 }));
+                    });
+                    insertText = ts.textChanges.applyChanges(syntheticFile_1.text, changes);
+                }
+                else { // Otherwise, just use emitter to print the new nodes.
+                    insertText = printer.printSnippetList(1 /* MultiLine */ | 131072 /* NoTrailingNewLine */, ts.factory.createNodeArray(completionNodes), sourceFile);
+                }
             }
             return { insertText: insertText, isSnippet: isSnippet, importAdder: importAdder };
         }
@@ -129757,8 +129872,8 @@ var ts;
             return undefined;
         }
         function createSnippetPrinter(printerOptions) {
-            var printer = ts.createPrinter(printerOptions);
-            var baseWriter = ts.createTextWriter(ts.getNewLineCharacter(printerOptions));
+            var baseWriter = ts.textChanges.createWriter(ts.getNewLineCharacter(printerOptions));
+            var printer = ts.createPrinter(printerOptions, baseWriter);
             var writer = __assign(__assign({}, baseWriter), { write: function (s) { return baseWriter.write(ts.escapeSnippetText(s)); }, nonEscapingWrite: baseWriter.write, writeLiteral: function (s) { return baseWriter.writeLiteral(ts.escapeSnippetText(s)); }, writeStringLiteral: function (s) { return baseWriter.writeStringLiteral(ts.escapeSnippetText(s)); }, writeSymbol: function (s, symbol) { return baseWriter.writeSymbol(ts.escapeSnippetText(s), symbol); }, writeParameter: function (s) { return baseWriter.writeParameter(ts.escapeSnippetText(s)); }, writeComment: function (s) { return baseWriter.writeComment(ts.escapeSnippetText(s)); }, writeProperty: function (s) { return baseWriter.writeProperty(ts.escapeSnippetText(s)); } });
             return {
                 printSnippetList: printSnippetList,
@@ -129863,7 +129978,7 @@ var ts;
                 return CompletionSource.ThisProperty;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
+        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
@@ -129884,7 +129999,7 @@ var ts;
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
                 var sortTextId = (_a = symbolToSortTextIdMap === null || symbolToSortTextIdMap === void 0 ? void 0 : symbolToSortTextIdMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : 11 /* LocationPriority */;
                 var sortText = (isDeprecated(symbol, typeChecker) ? 8 /* DeprecatedOffset */ + sortTextId : sortTextId).toString();
-                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind);
+                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind, formatContext);
                 if (!entry) {
                     continue;
                 }
@@ -130080,7 +130195,7 @@ var ts;
                 }
             }
             if (source === CompletionSource.ClassMemberSnippet) {
-                var importAdder = getEntryForMemberCompletion(host, program, compilerOptions, preferences, name, symbol, location, contextToken).importAdder;
+                var importAdder = getEntryForMemberCompletion(host, program, compilerOptions, preferences, name, symbol, location, contextToken, formatContext).importAdder;
                 if (importAdder) {
                     var changes = ts.textChanges.ChangeTracker.with({ host: host, formatContext: formatContext, preferences: preferences }, importAdder.writeFixes);
                     return {
@@ -145964,19 +146079,13 @@ var ts;
                     + ((!options.suffix || ts.endsWith(noIndent, options.suffix))
                         ? "" : options.suffix);
             }
-            function getFormatCodeSettingsForWriting(_a, sourceFile) {
-                var options = _a.options;
-                var shouldAutoDetectSemicolonPreference = !options.semicolons || options.semicolons === ts.SemicolonPreference.Ignore;
-                var shouldRemoveSemicolons = options.semicolons === ts.SemicolonPreference.Remove || shouldAutoDetectSemicolonPreference && !ts.probablyUsesSemicolons(sourceFile);
-                return __assign(__assign({}, options), { semicolons: shouldRemoveSemicolons ? ts.SemicolonPreference.Remove : ts.SemicolonPreference.Ignore });
-            }
             /** Note: this may mutate `nodeIn`. */
             function getFormattedTextOfNode(nodeIn, sourceFile, pos, _a, newLineCharacter, formatContext, validate) {
                 var indentation = _a.indentation, prefix = _a.prefix, delta = _a.delta;
                 var _b = getNonformattedText(nodeIn, sourceFile, newLineCharacter), node = _b.node, text = _b.text;
                 if (validate)
                     validate(node, text);
-                var formatOptions = getFormatCodeSettingsForWriting(formatContext, sourceFile);
+                var formatOptions = ts.getFormatCodeSettingsForWriting(formatContext, sourceFile);
                 var initialIndentation = indentation !== undefined
                     ? indentation
                     : ts.formatting.SmartIndenter.getIndentation(pos, sourceFile, formatOptions, prefix === newLineCharacter || ts.getLineStartPositionForPosition(pos, sourceFile) === pos);
@@ -146024,6 +146133,7 @@ var ts;
             ts.setTextRangePosEnd(newNode, getPos(node), getEnd(node));
             return newNode;
         }
+        textChanges_3.assignPositionsToNode = assignPositionsToNode;
         function assignPositionsToNodeArray(nodes, visitor, test, start, count) {
             var visited = ts.visitNodes(nodes, visitor, test, start, count);
             if (!visited) {
@@ -146194,6 +146304,7 @@ var ts;
                 clear: clear
             };
         }
+        textChanges_3.createWriter = createWriter;
         function getInsertionPositionAtSourceFileTop(sourceFile) {
             var lastPrologue;
             for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) {
@@ -150929,7 +151040,8 @@ var ts;
                 return { kind: 3 /* ObjectLiteral */, token: token, properties: properties, indentation: undefined, parentDeclaration: parent.initializer };
             }
             if (ts.isIdentifier(token) && ts.isJsxOpeningLikeElement(token.parent)) {
-                var attributes = getUnmatchedAttributes(checker, token.parent);
+                var target = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var attributes = getUnmatchedAttributes(checker, target, token.parent);
                 if (!ts.length(attributes))
                     return undefined;
                 return { kind: 4 /* JsxAttributes */, token: token, attributes: attributes, parentDeclaration: token.parent };
@@ -151164,8 +151276,12 @@ var ts;
             var jsxAttributesNode = info.parentDeclaration.attributes;
             var hasSpreadAttribute = ts.some(jsxAttributesNode.properties, ts.isJsxSpreadAttribute);
             var attrs = ts.map(info.attributes, function (attr) {
-                var value = attr.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(attr.valueDeclaration)) : createUndefined();
-                return ts.factory.createJsxAttribute(ts.factory.createIdentifier(attr.name), ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, value));
+                var value = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(attr));
+                var name = ts.factory.createIdentifier(attr.name);
+                var jsxAttribute = ts.factory.createJsxAttribute(name, ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, value));
+                // formattingScanner requires the Identifier to have a context for scanning attributes with "-" (data-foo).
+                ts.setParent(name, jsxAttribute);
+                return jsxAttribute;
             });
             var jsxAttributes = ts.factory.createJsxAttributes(hasSpreadAttribute ? __spreadArray(__spreadArray([], attrs, true), jsxAttributesNode.properties, true) : __spreadArray(__spreadArray([], jsxAttributesNode.properties, true), attrs, true));
             var options = { prefix: jsxAttributesNode.pos === jsxAttributesNode.end ? " " : undefined };
@@ -151174,10 +151290,11 @@ var ts;
         function addObjectLiteralProperties(changes, context, info) {
             var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
             var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences);
+            var target = ts.getEmitScriptTarget(context.program.getCompilerOptions());
             var checker = context.program.getTypeChecker();
             var props = ts.map(info.properties, function (prop) {
-                var initializer = prop.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(prop.valueDeclaration)) : createUndefined();
-                return ts.factory.createPropertyAssignment(prop.name, initializer);
+                var initializer = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(prop));
+                return ts.factory.createPropertyAssignment(ts.createPropertyNameNodeForIdentifierOrLiteral(prop.name, target, quotePreference === 0 /* Single */), initializer);
             });
             var options = {
                 leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude,
@@ -151264,7 +151381,7 @@ var ts;
             return (type.flags & 524288 /* Object */) &&
                 ((ts.getObjectFlags(type) & 128 /* ObjectLiteral */) || (type.symbol && ts.tryCast(ts.singleOrUndefined(type.symbol.declarations), ts.isTypeLiteralNode)));
         }
-        function getUnmatchedAttributes(checker, source) {
+        function getUnmatchedAttributes(checker, target, source) {
             var attrsType = checker.getContextualType(source.attributes);
             if (attrsType === undefined)
                 return ts.emptyArray;
@@ -151286,7 +151403,7 @@ var ts;
                 }
             }
             return ts.filter(targetProps, function (targetProp) {
-                return !((targetProp.flags & 16777216 /* Optional */ || ts.getCheckFlags(targetProp) & 48 /* Partial */) || seenNames.has(targetProp.escapedName));
+                return ts.isIdentifierText(targetProp.name, target, 1 /* JSX */) && !((targetProp.flags & 16777216 /* Optional */ || ts.getCheckFlags(targetProp) & 48 /* Partial */) || seenNames.has(targetProp.escapedName));
             });
         }
     })(codefix = ts.codefix || (ts.codefix = {}));
@@ -161091,12 +161208,12 @@ var ts;
             synchronizeHostData();
             return __spreadArray(__spreadArray([], program.getOptionsDiagnostics(cancellationToken), true), program.getGlobalDiagnostics(cancellationToken), true);
         }
-        function getCompletionsAtPosition(fileName, position, options) {
+        function getCompletionsAtPosition(fileName, position, options, formattingSettings) {
             if (options === void 0) { options = ts.emptyOptions; }
             // Convert from deprecated options names to new names
             var fullPreferences = __assign(__assign({}, ts.identity(options)), { includeCompletionsForModuleExports: options.includeCompletionsForModuleExports || options.includeExternalModuleExports, includeCompletionsWithInsertText: options.includeCompletionsWithInsertText || options.includeInsertTextCompletions });
             synchronizeHostData();
-            return ts.Completions.getCompletionsAtPosition(host, program, log, getValidSourceFile(fileName), position, fullPreferences, options.triggerCharacter, options.triggerKind, cancellationToken);
+            return ts.Completions.getCompletionsAtPosition(host, program, log, getValidSourceFile(fileName), position, fullPreferences, options.triggerCharacter, options.triggerKind, cancellationToken, formattingSettings && ts.formatting.getFormatContext(formattingSettings, host));
         }
         function getCompletionEntryDetails(fileName, position, name, formattingOptions, source, preferences, data) {
             if (preferences === void 0) { preferences = ts.emptyOptions; }
@@ -163259,9 +163376,9 @@ var ts;
          * to provide at the given source position and providing a member completion
          * list if requested.
          */
-        LanguageServiceShimObject.prototype.getCompletionsAtPosition = function (fileName, position, preferences) {
+        LanguageServiceShimObject.prototype.getCompletionsAtPosition = function (fileName, position, preferences, formattingSettings) {
             var _this = this;
-            return this.forwardJSONCall("getCompletionsAtPosition('" + fileName + "', " + position + ", " + preferences + ")", function () { return _this.languageService.getCompletionsAtPosition(fileName, position, preferences); });
+            return this.forwardJSONCall("getCompletionsAtPosition('" + fileName + "', " + position + ", " + preferences + ", " + formattingSettings + ")", function () { return _this.languageService.getCompletionsAtPosition(fileName, position, preferences, formattingSettings); });
         };
         /** Get a string based representation of a completion list entry details */
         LanguageServiceShimObject.prototype.getCompletionEntryDetails = function (fileName, position, entryName, formatOptions, source, preferences, data) {
@@ -171427,6 +171544,9 @@ var ts;
                     }
                     return;
                 }
+                this.writeMessage(msg);
+            };
+            Session.prototype.writeMessage = function (msg) {
                 var msgText = formatMessage(msg, this.logger, this.byteLength, this.host.newLine);
                 ts.perfLogger.logEvent("Response message size: " + msgText.length);
                 this.host.write(msgText);
@@ -172178,7 +172298,7 @@ var ts;
                 var _a = this.getFileAndProject(args), file = _a.file, project = _a.project;
                 var scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
                 var position = this.getPosition(args, scriptInfo);
-                var completions = project.getLanguageService().getCompletionsAtPosition(file, position, __assign(__assign({}, server.convertUserPreferences(this.getPreferences(file))), { triggerCharacter: args.triggerCharacter, triggerKind: args.triggerKind, includeExternalModuleExports: args.includeExternalModuleExports, includeInsertTextCompletions: args.includeInsertTextCompletions }));
+                var completions = project.getLanguageService().getCompletionsAtPosition(file, position, __assign(__assign({}, server.convertUserPreferences(this.getPreferences(file))), { triggerCharacter: args.triggerCharacter, triggerKind: args.triggerKind, includeExternalModuleExports: args.includeExternalModuleExports, includeInsertTextCompletions: args.includeInsertTextCompletions }), project.projectService.getFormatCodeOptions(file));
                 if (completions === undefined)
                     return undefined;
                 if (kind === "completions-full" /* CompletionsFull */)