@typescript-deploys/pr-build 4.6.0-pr-47183-2 → 4.6.0-pr-47400-2

package/lib/tsserver.js

@@ -100,7 +100,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-insiders.20211217";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220113";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -14456,7 +14456,8 @@ var ts;
                 Float64Array: ["at"],
                 BigInt64Array: ["at"],
                 BigUint64Array: ["at"],
-                ObjectConstructor: ["hasOwn"]
+                ObjectConstructor: ["hasOwn"],
+                Error: ["cause"]
             }
         };
     }
@@ -19790,16 +19791,6 @@ var ts;
                     (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(symlinkPath, real);
                 }
             },
-            setSymlinkedDirectoryFromSymlinkedFile: function (symlink, real) {
-                this.setSymlinkedFile(ts.toPath(symlink, cwd, getCanonicalFileName), real);
-                var _a = guessDirectorySymlink(real, symlink, cwd, getCanonicalFileName) || ts.emptyArray, commonResolved = _a[0], commonOriginal = _a[1];
-                if (commonResolved && commonOriginal) {
-                    this.setSymlinkedDirectory(commonOriginal, {
-                        real: commonResolved,
-                        realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName),
-                    });
-                }
-            },
             setSymlinksFromResolutions: function (files, typeReferenceDirectives) {
                 var _this = this;
                 var _a;
@@ -20767,9 +20758,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);
     }
@@ -22242,7 +22264,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
@@ -26199,32 +26221,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) {
@@ -41473,9 +41499,7 @@ var ts;
             }
         }
         var failedLookupLocations = [];
-        var features = ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
-            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
-                NodeResolutionFeatures.None;
+        var features = getDefaultNodeResolutionFeatures(options);
         var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: ["node", "require", "types"] };
         var resolved = primaryLookup();
         var primary = true;
@@ -41560,6 +41584,34 @@ var ts;
         }
     }
     ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
+    function getDefaultNodeResolutionFeatures(options) {
+        return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
+            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
+                NodeResolutionFeatures.None;
+    }
+    /**
+     * @internal
+     * Does not try `@types/${packageName}` - use a second pass if needed.
+     */
+    function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
+            conditions: ts.emptyArray,
+            features: NodeResolutionFeatures.None,
+        };
+        return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
+            if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
+                var nodeModulesFolder = ts.combinePaths(ancestorDirectory, "node_modules");
+                var candidate = ts.combinePaths(nodeModulesFolder, packageName);
+                return getPackageJsonInfo(candidate, /*onlyRecordFailures*/ false, moduleResolutionState);
+            }
+        });
+    }
+    ts.resolvePackageNameToPackageJson = resolvePackageNameToPackageJson;
     /**
      * Given a set of options, returns the set of type directive names
      *   that should be included for this program automatically.
@@ -42133,11 +42185,6 @@ var ts;
     }
     ts.resolveJSModule = resolveJSModule;
     /* @internal */
-    function tryResolveJSModule(moduleName, initialDir, host) {
-        return tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule;
-    }
-    ts.tryResolveJSModule = tryResolveJSModule;
-    /* @internal */
     var NodeResolutionFeatures;
     (function (NodeResolutionFeatures) {
         NodeResolutionFeatures[NodeResolutionFeatures["None"] = 0] = "None";
@@ -42445,6 +42492,97 @@ var ts;
         var versionPaths = packageInfo && packageInfo.versionPaths;
         return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
     }
+    /* @internal */
+    function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache, resolveJs) {
+        if (!resolveJs && packageJsonInfo.resolvedEntrypoints !== undefined) {
+            // Cached value excludes resolutions to JS files - those could be
+            // cached separately, but they're used rarely.
+            return packageJsonInfo.resolvedEntrypoints;
+        }
+        var entrypoints;
+        var extensions = resolveJs ? Extensions.JavaScript : Extensions.TypeScript;
+        var features = getDefaultNodeResolutionFeatures(options);
+        var requireState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
+            conditions: ["node", "require", "types"],
+            features: features,
+        };
+        var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, 
+        /*onlyRecordFailures*/ false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
+        entrypoints = ts.append(entrypoints, requireResolution === null || requireResolution === void 0 ? void 0 : requireResolution.path);
+        if (features & NodeResolutionFeatures.Exports && packageJsonInfo.packageJsonContent.exports) {
+            for (var _i = 0, _a = [["node", "import", "types"], ["node", "require", "types"]]; _i < _a.length; _i++) {
+                var conditions = _a[_i];
+                var exportState = __assign(__assign({}, requireState), { failedLookupLocations: [], conditions: conditions });
+                var exportResolutions = loadEntrypointsFromExportMap(packageJsonInfo, packageJsonInfo.packageJsonContent.exports, exportState, extensions);
+                if (exportResolutions) {
+                    for (var _b = 0, exportResolutions_1 = exportResolutions; _b < exportResolutions_1.length; _b++) {
+                        var resolution = exportResolutions_1[_b];
+                        entrypoints = ts.appendIfUnique(entrypoints, resolution.path);
+                    }
+                }
+            }
+        }
+        return packageJsonInfo.resolvedEntrypoints = entrypoints || false;
+    }
+    ts.getEntrypointsFromPackageJsonInfo = getEntrypointsFromPackageJsonInfo;
+    function loadEntrypointsFromExportMap(scope, exports, state, extensions) {
+        var entrypoints;
+        if (ts.isArray(exports)) {
+            for (var _i = 0, exports_1 = exports; _i < exports_1.length; _i++) {
+                var target = exports_1[_i];
+                loadEntrypointsFromTargetExports(target);
+            }
+        }
+        // eslint-disable-next-line no-null/no-null
+        else if (typeof exports === "object" && exports !== null && allKeysStartWithDot(exports)) {
+            for (var key in exports) {
+                loadEntrypointsFromTargetExports(exports[key]);
+            }
+        }
+        else {
+            loadEntrypointsFromTargetExports(exports);
+        }
+        return entrypoints;
+        function loadEntrypointsFromTargetExports(target) {
+            var _a, _b;
+            if (typeof target === "string" && ts.startsWith(target, "./") && target.indexOf("*") === -1) {
+                var partsAfterFirst = ts.getPathComponents(target).slice(2);
+                if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
+                    return false;
+                }
+                var resolvedTarget = ts.combinePaths(scope.packageDirectory, target);
+                var finalPath = ts.getNormalizedAbsolutePath(resolvedTarget, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                var result = loadJSOrExactTSFileName(extensions, finalPath, /*recordOnlyFailures*/ false, state);
+                if (result) {
+                    entrypoints = ts.appendIfUnique(entrypoints, result, function (a, b) { return a.path === b.path; });
+                    return true;
+                }
+            }
+            else if (Array.isArray(target)) {
+                for (var _i = 0, target_1 = target; _i < target_1.length; _i++) {
+                    var t = target_1[_i];
+                    var success = loadEntrypointsFromTargetExports(t);
+                    if (success) {
+                        return true;
+                    }
+                }
+            }
+            // eslint-disable-next-line no-null/no-null
+            else if (typeof target === "object" && target !== null) {
+                return ts.forEach(ts.getOwnKeys(target), function (key) {
+                    if (key === "default" || ts.contains(state.conditions, key) || isApplicableVersionedTypesKey(state.conditions, key)) {
+                        loadEntrypointsFromTargetExports(target[key]);
+                        return true;
+                    }
+                });
+            }
+        }
+    }
     /**
      * A function for locating the package.json scope for a given path
      */
@@ -42501,7 +42639,7 @@ var ts;
                 trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
             var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
-            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths };
+            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
             (_b = state.packageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
             return result;
         }
@@ -42798,8 +42936,8 @@ var ts;
                         }
                         return toSearchResult(/*value*/ undefined);
                     }
-                    for (var _d = 0, target_1 = target; _d < target_1.length; _d++) {
-                        var elem = target_1[_d];
+                    for (var _d = 0, target_2 = target; _d < target_2.length; _d++) {
+                        var elem = target_2[_d];
                         var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
                         if (result) {
                             return result;
@@ -46838,6 +46976,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)
@@ -49827,7 +49966,7 @@ var ts;
                         if (!sigs || !sigs.length) {
                             sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
                         }
-                        if ((sigs && sigs.length) || getPropertyOfType(type, "default" /* Default */)) {
+                        if ((sigs && sigs.length) || getPropertyOfType(type, "default" /* Default */, /*skipObjectFunctionPropertyAugment*/ true)) {
                             var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference);
                             return cloneTypeAsModuleType(symbol, moduleType, referenceParent);
                         }
@@ -52031,8 +52170,8 @@ var ts;
                     }
                     else {
                         if (parent && getExportsOfSymbol(parent)) {
-                            var exports_1 = getExportsOfSymbol(parent);
-                            ts.forEachEntry(exports_1, function (ex, name) {
+                            var exports_2 = getExportsOfSymbol(parent);
+                            ts.forEachEntry(exports_2, function (ex, name) {
                                 if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=" /* ExportEquals */) {
                                     symbolName = ts.unescapeLeadingUnderscores(name);
                                     return true;
@@ -52193,7 +52332,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) {
@@ -52201,24 +52340,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
@@ -53734,10 +53868,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;
@@ -57148,6 +57282,11 @@ var ts;
             return simplified !== type ? simplified : getConstraintOfType(type);
         }
         function getConstraintFromIndexedAccess(type) {
+            if (isMappedTypeGenericIndexedAccess(type)) {
+                // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic,
+                // we substitute an instantiation of E where P is replaced with X.
+                return substituteIndexedMappedType(type.objectType, type.indexType);
+            }
             var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
             if (indexConstraint && indexConstraint !== type.indexType) {
                 var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.accessFlags);
@@ -57352,6 +57491,11 @@ var ts;
                     return constraint ? getStringMappingType(t.symbol, constraint) : stringType;
                 }
                 if (t.flags & 8388608 /* IndexedAccess */) {
+                    if (isMappedTypeGenericIndexedAccess(t)) {
+                        // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic,
+                        // we substitute an instantiation of E where P is replaced with X.
+                        return getBaseConstraint(substituteIndexedMappedType(t.objectType, t.indexType));
+                    }
                     var baseObjectType = getBaseConstraint(t.objectType);
                     var baseIndexType = getBaseConstraint(t.indexType);
                     var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.accessFlags);
@@ -57436,13 +57580,7 @@ var ts;
          * type itself.
          */
         function getApparentType(type) {
-            // We obtain the base constraint for all instantiable types, except indexed access types of the form
-            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
-            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
-            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
-            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
-                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
-                    getBaseConstraintOfType(type) || unknownType;
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -57724,7 +57862,7 @@ var ts;
                         return symbol_1;
                     }
                 }
-                return globalObjectType === undefined ? undefined : getPropertyOfObjectType(globalObjectType, name);
+                return getPropertyOfObjectType(globalObjectType, name);
             }
             if (type.flags & 3145728 /* UnionOrIntersection */) {
                 return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
@@ -57780,7 +57918,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 */) {
@@ -60346,7 +60484,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)) {
@@ -60631,7 +60769,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;
                     }
@@ -64106,6 +64244,17 @@ var ts;
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
+                        if (isMappedTypeGenericIndexedAccess(source)) {
+                            // For an indexed access type { [P in K]: E}[X], above we have already explored an instantiation of E with X
+                            // substituted for P. We also want to explore type { [P in K]: E }[C], where C is the constraint of X.
+                            var indexConstraint = getConstraintOfType(source.indexType);
+                            if (indexConstraint) {
+                                if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* Source */, reportErrors)) {
+                                    resetErrorInfo(saveErrorInfo);
+                                    return result;
+                                }
+                            }
+                        }
                     }
                 }
                 else if (source.flags & 4194304 /* Index */) {
@@ -64173,7 +64322,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);
@@ -64719,7 +64868,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);
@@ -64792,7 +64941,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
@@ -65827,9 +65977,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 */);
@@ -67437,7 +67590,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)) {
@@ -68777,13 +68931,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;
                         }
                     }
@@ -69585,42 +69740,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));
+                            }
                         }
                     }
                 }
@@ -70761,7 +70952,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;
                         }
                     }
@@ -71402,10 +71593,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;
             }
@@ -71415,30 +71606,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) {
@@ -71474,7 +71641,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;
@@ -72697,6 +72864,9 @@ var ts;
                 if (compilerOptions.noPropertyAccessFromIndexSignature && ts.isPropertyAccessExpression(node)) {
                     error(right, ts.Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, ts.unescapeLeadingUnderscores(right.escapedText));
                 }
+                if (indexInfo.declaration && ts.getCombinedNodeFlags(indexInfo.declaration) & 134217728 /* Deprecated */) {
+                    addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText);
+                }
             }
             else {
                 if (prop.declarations && getDeclarationNodeFlagsFromSymbol(prop) & 134217728 /* Deprecated */ && isUncalledFunctionReference(node, prop)) {
@@ -82412,7 +82582,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);
                 }
             }
@@ -83206,9 +83376,9 @@ var ts;
                     }
                 }
                 // Checks for export * conflicts
-                var exports_2 = getExportsOfModule(moduleSymbol);
-                if (exports_2) {
-                    exports_2.forEach(function (_a, id) {
+                var exports_3 = getExportsOfModule(moduleSymbol);
+                if (exports_3) {
+                    exports_3.forEach(function (_a, id) {
                         var declarations = _a.declarations, flags = _a.flags;
                         if (id === "__export") {
                             return;
@@ -92764,6 +92934,11 @@ var ts;
                 ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
                 ts.setCommentRange(statement, property);
                 ts.setOriginalNode(statement, property);
+                // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
+                // `statement` and `expression` have a copy of the synthesized comments.
+                // Drop the comments from expression to avoid printing them twice.
+                ts.setSyntheticLeadingComments(expression, undefined);
+                ts.setSyntheticTrailingComments(expression, undefined);
                 statements.push(statement);
             }
         }
@@ -109018,7 +109193,7 @@ var ts;
                     emitPlaceholder(hint, node, snippet);
                     break;
                 case 0 /* TabStop */:
-                    emitTabStop(snippet);
+                    emitTabStop(hint, node, snippet);
                     break;
             }
         }
@@ -109028,7 +109203,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);
         }
         //
@@ -119101,28 +119279,37 @@ var ts;
                 useCaseSensitiveFileNames: (_a = host.useCaseSensitiveFileNames) === null || _a === void 0 ? void 0 : _a.call(host),
             };
         }
-        function updateModuleSpecifier(compilerOptions, importingSourceFileName, toFileName, host, oldImportSpecifier) {
-            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
+        // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`?
+        // Because when this is called by the file renamer, `importingSourceFile` is the file being renamed,
+        // while `importingSourceFileName` its *new* name. We need a source file just to get its
+        // `impliedNodeFormat` and to detect certain preferences from existing import module specifiers.
+        function updateModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, oldImportSpecifier) {
+            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
             if (res === oldImportSpecifier)
                 return undefined;
             return res;
         }
         moduleSpecifiers_1.updateModuleSpecifier = updateModuleSpecifier;
-        // Note: importingSourceFile is just for usesJsExtensionOnImports
+        // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`?
+        // Because when this is called by the declaration emitter, `importingSourceFile` is the implementation
+        // file, but `importingSourceFileName` and `toFileName` refer to declaration files (the former to the
+        // one currently being produced; the latter to the one being imported). We need an implementation file
+        // just to get its `impliedNodeFormat` and to detect certain preferences from existing import module
+        // specifiers.
         function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host) {
-            return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
+            return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
         }
         moduleSpecifiers_1.getModuleSpecifier = getModuleSpecifier;
-        function getNodeModulesPackageName(compilerOptions, importingSourceFileName, nodeModulesFileName, host, preferences) {
-            var info = getInfo(importingSourceFileName, host);
-            var modulePaths = getAllModulePaths(importingSourceFileName, nodeModulesFileName, host, preferences);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions, /*packageNameOnly*/ true); });
+        function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences) {
+            var info = getInfo(importingSourceFile.path, host);
+            var modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences);
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, /*packageNameOnly*/ true); });
         }
         moduleSpecifiers_1.getNodeModulesPackageName = getNodeModulesPackageName;
-        function getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, preferences, userPreferences) {
+        function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, preferences, userPreferences) {
             var info = getInfo(importingSourceFileName, host);
             var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions); }) ||
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions); }) ||
                 getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
         }
         function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences) {
@@ -119189,7 +119376,7 @@ var ts;
             var relativeSpecifiers;
             for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) {
                 var modulePath = modulePaths_1[_i];
-                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions);
+                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions);
                 nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier);
                 if (specifier && modulePath.isRedirect) {
                     // If we got a specifier for a redirect, it was a bare package specifier (e.g. "@foo/bar",
@@ -119581,7 +119768,7 @@ var ts;
                 ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
                 : ts.removeFileExtension(relativePath);
         }
-        function tryGetModuleNameAsNodeModule(_a, _b, host, options, packageNameOnly) {
+        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, packageNameOnly) {
             var path = _a.path, isRedirect = _a.isRedirect;
             var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory;
             if (!host.fileExists || !host.readFile) {
@@ -119644,11 +119831,19 @@ var ts;
                 var moduleFileToTry = path;
                 if (host.fileExists(packageJsonPath)) {
                     var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
-                    // TODO: Inject `require` or `import` condition based on the intended import mode
                     if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
-                        var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
+                        // `conditions` *could* be made to go against `importingSourceFile.impliedNodeFormat` if something wanted to generate
+                        // an ImportEqualsDeclaration in an ESM-implied file or an ImportCall in a CJS-implied file. But since this function is
+                        // usually called to conjure an import out of thin air, we don't have an existing usage to call `getModeForUsageAtIndex`
+                        // with, so for now we just stick with the mode of the file.
+                        var conditions = ["node", importingSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext ? "import" : "require", "types"];
+                        var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string"
+                            ? tryGetModuleNameFromExports(options, path, packageRootPath, ts.getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions)
+                            : undefined;
                         if (fromExports) {
-                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
+                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry)
+                                ? fromExports
+                                : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
                             return __assign(__assign({}, withJsExtension), { verbatimFromExports: true });
                         }
                         if (packageJsonContent.exports) {
@@ -119754,8 +119949,8 @@ var ts;
         }
         function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
             return ts.firstDefined(rootDirs, function (rootDir) {
-                var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName); // TODO: GH#18217
-                return isPathRelativeToParent(relativePath) ? undefined : relativePath;
+                var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
+                return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
         }
         function removeExtensionAndIndexPostFix(fileName, ending, options) {
@@ -119874,7 +120069,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 ?
@@ -119935,7 +120130,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; });
@@ -119950,10 +120145,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 "";
@@ -119972,7 +120167,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;
     }
@@ -120390,7 +120586,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;
@@ -125966,7 +126162,7 @@ var ts;
             if (!ts.stringContains(importedFileName, "node_modules")) {
                 return undefined;
             }
-            var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile.path, importedFileName, moduleSpecifierResolutionHost, preferences);
+            var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile, importedFileName, moduleSpecifierResolutionHost, preferences);
             if (!specifier) {
                 return undefined;
             }
@@ -126166,6 +126362,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*/
@@ -127789,7 +127995,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 */: {
@@ -128610,7 +128817,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)) {
@@ -128650,7 +128857,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);
                     }
@@ -128770,7 +128977,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 */) {
@@ -128782,7 +128989,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 {
@@ -128790,7 +128997,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; }));
@@ -128896,7 +129103,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);
@@ -128961,7 +129168,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;
@@ -129060,7 +129267,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 };
@@ -129077,15 +129284,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);
@@ -129131,7 +129339,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 };
         }
@@ -129175,8 +129403,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,
@@ -129281,7 +129509,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);
@@ -129302,7 +129530,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;
                 }
@@ -129498,7 +129726,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 {
@@ -135580,7 +135808,7 @@ var ts;
                     : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew);
                 // Need an update if the imported file moved, or the importing file moved and was using a relative path.
                 return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && ts.pathIsRelative(importLiteral.text)))
-                    ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text)
+                    ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text)
                     : undefined;
             });
         };
@@ -137225,6 +137453,9 @@ var ts;
         // We use 1 NavNode to represent 'A.B.C', but there are multiple source nodes.
         // Only merge module nodes that have the same chain. Don't merge 'A.B.C' with 'A'!
         function areSameModule(a, b) {
+            if (!a.body || !b.body) {
+                return a.body === b.body;
+            }
             return a.body.kind === b.body.kind && (a.body.kind !== 260 /* ModuleDeclaration */ || areSameModule(a.body, b.body));
         }
         /** Merge source into target. Source should be thrown away after this is called. */
@@ -145382,19 +145613,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);
@@ -145442,6 +145667,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) {
@@ -145612,6 +145838,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++) {
@@ -150347,7 +150574,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 };
@@ -150582,8 +150810,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 };
@@ -150592,10 +150824,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,
@@ -150682,7 +150915,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;
@@ -150704,7 +150937,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 = {}));
@@ -154437,7 +154670,7 @@ var ts;
                 defaultToNamedAction.kind,
                 namedToDefaultAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndDefaultExports(context) {
                 var info = getInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -154455,7 +154688,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndDefaultExports(context, actionName) {
                 ts.Debug.assert(actionName === defaultToNamedAction.name || actionName === namedToDefaultAction.name, "Unexpected action name");
                 var info = getInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -154683,7 +154916,7 @@ var ts;
                 namespaceToNamedAction.kind,
                 namedToNamespaceAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndNamespacedImports(context) {
                 var info = getImportToConvert(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -154702,7 +154935,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndNamespacedImports(context, actionName) {
                 ts.Debug.assert(actionName === namespaceToNamedAction.name || actionName === namedToNamespaceAction.name, "Unexpected action name");
                 var info = getImportToConvert(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -154868,10 +155101,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [toOptionalChainAction.kind],
-                getAvailableActions: getAvailableActions,
-                getEditsForAction: getEditsForAction
+                getEditsForAction: getRefactorEditsToConvertToOptionalChain,
+                getAvailableActions: getRefactorActionsToConvertToOptionalChain,
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertToOptionalChain(context) {
                 var info = getInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -154891,7 +155124,7 @@ var ts;
                 }
                 return ts.emptyArray;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertToOptionalChain(context, actionName) {
                 var info = getInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) {
@@ -155134,10 +155367,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [functionOverloadAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature,
+                getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertOverloadsToOneSignature(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var info = getConvertableOverloadListAtPosition(file, startPosition, program);
                 if (!info)
@@ -155148,7 +155381,7 @@ var ts;
                         actions: [functionOverloadAction]
                     }];
             }
-            function getEditsForAction(context) {
+            function getRefactorEditsToConvertOverloadsToOneSignature(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var signatureDecls = getConvertableOverloadListAtPosition(file, startPosition, program);
                 if (!signatureDecls)
@@ -155304,14 +155537,14 @@ var ts;
                     extractConstantAction.kind,
                     extractFunctionAction.kind
                 ],
-                getAvailableActions: getAvailableActions,
-                getEditsForAction: getEditsForAction
+                getEditsForAction: getRefactorEditsToExtractSymbol,
+                getAvailableActions: getRefactorActionsToExtractSymbol,
             });
             /**
              * Compute the associated code actions
              * Exported for tests.
              */
-            function getAvailableActions(context) {
+            function getRefactorActionsToExtractSymbol(context) {
                 var requestedRefactor = context.kind;
                 var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context), context.triggerReason === "invoked");
                 var targetRange = rangeToExtract.targetRange;
@@ -155440,9 +155673,9 @@ var ts;
                     return error;
                 }
             }
-            extractSymbol.getAvailableActions = getAvailableActions;
+            extractSymbol.getRefactorActionsToExtractSymbol = getRefactorActionsToExtractSymbol;
             /* Exported for tests */
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToExtractSymbol(context, actionName) {
                 var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context));
                 var targetRange = rangeToExtract.targetRange; // TODO:GH#18217
                 var parsedFunctionIndexMatch = /^function_scope_(\d+)$/.exec(actionName);
@@ -155459,7 +155692,7 @@ var ts;
                 }
                 ts.Debug.fail("Unrecognized action name");
             }
-            extractSymbol.getEditsForAction = getEditsForAction;
+            extractSymbol.getRefactorEditsToExtractSymbol = getRefactorEditsToExtractSymbol;
             // Move these into diagnostic messages if they become user-facing
             var Messages;
             (function (Messages) {
@@ -157010,7 +157243,7 @@ var ts;
                 extractToInterfaceAction.kind,
                 extractToTypeDefAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToExtractType(context) {
                 var info = getRangeToExtract(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -157035,7 +157268,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToExtractType(context, actionName) {
                 var file = context.file;
                 var info = getRangeToExtract(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected to find a range to extract");
@@ -157203,7 +157436,7 @@ var ts;
             };
             refactor.registerRefactor(actionName, {
                 kinds: [generateGetSetAction.kind],
-                getEditsForAction: function (context, actionName) {
+                getEditsForAction: function getRefactorActionsToGenerateGetAndSetAccessors(context, actionName) {
                     if (!context.endPosition)
                         return undefined;
                     var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition);
@@ -157282,7 +157515,7 @@ var ts;
         };
         refactor.registerRefactor(refactorName, {
             kinds: [moveToNewFileAction.kind],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
                 var statements = getStatementsToMove(context);
                 if (context.preferences.allowTextChangesInNewFiles && statements) {
                     return [{ name: refactorName, description: description, actions: [moveToNewFileAction] }];
@@ -157293,7 +157526,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName) {
                 ts.Debug.assert(actionName === refactorName, "Wrong refactor invoked");
                 var statements = ts.Debug.checkDefined(getStatementsToMove(context));
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, statements, t, context.host, context.preferences); });
@@ -158024,10 +158257,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [removeBracesAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToRemoveFunctionBraces,
+                getAvailableActions: getRefactorActionsToRemoveFunctionBraces
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToRemoveFunctionBraces(context) {
                 var file = context.file, startPosition = context.startPosition, triggerReason = context.triggerReason;
                 var info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked");
                 if (!info)
@@ -158053,7 +158286,7 @@ var ts;
                 }
                 return ts.emptyArray;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToRemoveFunctionBraces(context, actionName) {
                 var file = context.file, startPosition = context.startPosition;
                 var info = getConvertibleArrowFunctionAtPosition(file, startPosition);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -158127,10 +158360,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [toDestructuredAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject,
+                getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertParametersToDestructuredObject(context) {
                 var file = context.file, startPosition = context.startPosition;
                 var isJSFile = ts.isSourceFileJS(file);
                 if (isJSFile)
@@ -158144,7 +158377,7 @@ var ts;
                         actions: [toDestructuredAction]
                     }];
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName) {
                 ts.Debug.assert(actionName === refactorName, "Unexpected action name");
                 var file = context.file, startPosition = context.startPosition, program = context.program, cancellationToken = context.cancellationToken, host = context.host;
                 var functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
@@ -158654,10 +158887,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [convertStringAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertToTemplateString,
+                getAvailableActions: getRefactorActionsToConvertToTemplateString
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertToTemplateString(context) {
                 var file = context.file, startPosition = context.startPosition;
                 var node = getNodeOrParentOfParentheses(file, startPosition);
                 var maybeBinary = getParentBinaryExpression(node);
@@ -158683,7 +158916,7 @@ var ts;
                 }
                 return node;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertToTemplateString(context, actionName) {
                 var file = context.file, startPosition = context.startPosition;
                 var node = getNodeOrParentOfParentheses(file, startPosition);
                 switch (actionName) {
@@ -158897,10 +159130,10 @@ var ts;
                     toNamedFunctionAction.kind,
                     toArrowFunctionAction.kind
                 ],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertFunctionExpressions,
+                getAvailableActions: getRefactorActionsToConvertFunctionExpressions
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertFunctionExpressions(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program, kind = context.kind;
                 var info = getFunctionInfo(file, startPosition, program);
                 if (!info)
@@ -158944,7 +159177,7 @@ var ts;
                             errors : possibleActions
                     }];
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertFunctionExpressions(context, actionName) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var info = getFunctionInfo(file, startPosition, program);
                 if (!info)
@@ -159104,10 +159337,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [inferReturnTypeAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToInferReturnType,
+                getAvailableActions: getRefactorActionsToInferReturnType
             });
-            function getEditsForAction(context) {
+            function getRefactorEditsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (info && !refactor.isRefactorErrorInfo(info)) {
                     var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, t, info.declaration, info.returnTypeNode); });
@@ -159115,7 +159348,7 @@ var ts;
                 }
                 return undefined;
             }
-            function getAvailableActions(context) {
+            function getRefactorActionsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (!info)
                     return ts.emptyArray;
@@ -160509,12 +160742,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; }
@@ -162677,9 +162910,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) {
@@ -163208,14 +163441,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);
@@ -163264,16 +163491,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"
@@ -163299,55 +163610,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;
@@ -166186,30 +166448,43 @@ var ts;
                     (_b = packageJson.peerDependencies) === null || _b === void 0 ? void 0 : _b.forEach(function (_, dependencyName) { return addDependency(dependencyName); });
                 }
                 if (dependencyNames) {
-                    var resolutions = ts.mapDefined(ts.arrayFrom(dependencyNames.keys()), function (name) {
-                        var types = ts.resolveTypeReferenceDirective(name, rootFileName, compilerOptions, moduleResolutionHost);
-                        if (types.resolvedTypeReferenceDirective) {
-                            return types.resolvedTypeReferenceDirective;
-                        }
-                        if (compilerOptions.allowJs && compilerOptions.maxNodeModuleJsDepth) {
-                            return ts.tryResolveJSModule(name, hostProject.currentDirectory, moduleResolutionHost);
-                        }
-                    });
+                    var dependenciesAdded = 0;
                     var symlinkCache = hostProject.getSymlinkCache();
-                    for (var _c = 0, resolutions_1 = resolutions; _c < resolutions_1.length; _c++) {
-                        var resolution = resolutions_1[_c];
-                        if (!resolution.resolvedFileName)
+                    for (var _c = 0, _d = ts.arrayFrom(dependencyNames.keys()); _c < _d.length; _c++) {
+                        var name = _d[_c];
+                        // Avoid creating a large project that would significantly slow down time to editor interactivity
+                        if (dependencySelection === 2 /* Auto */ && dependenciesAdded > this.maxDependencies) {
+                            hostProject.log("Auto-import provider attempted to add more than " + this.maxDependencies + " dependencies.");
+                            return ts.emptyArray;
+                        }
+                        // 1. Try to load from the implementation package. For many dependencies, the
+                        //    package.json will exist, but the package will not contain any typings,
+                        //    so `entrypoints` will be undefined. In that case, or if the dependency
+                        //    is missing altogether, we will move on to trying the @types package (2).
+                        var packageJson = ts.resolvePackageNameToPackageJson(name, hostProject.currentDirectory, compilerOptions, moduleResolutionHost, program.getModuleResolutionCache());
+                        if (packageJson) {
+                            var entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache);
+                            if (entrypoints) {
+                                rootNames = ts.concatenate(rootNames, entrypoints);
+                                dependenciesAdded += entrypoints.length ? 1 : 0;
+                                continue;
+                            }
+                        }
+                        // 2. Try to load from the @types package.
+                        var typesPackageJson = ts.resolvePackageNameToPackageJson("@types/" + name, hostProject.currentDirectory, compilerOptions, moduleResolutionHost, program.getModuleResolutionCache());
+                        if (typesPackageJson) {
+                            var entrypoints = getRootNamesFromPackageJson(typesPackageJson, program, symlinkCache);
+                            rootNames = ts.concatenate(rootNames, entrypoints);
+                            dependenciesAdded += (entrypoints === null || entrypoints === void 0 ? void 0 : entrypoints.length) ? 1 : 0;
                             continue;
-                        var resolvedFileName = resolution.resolvedFileName, originalPath = resolution.originalPath;
-                        if (originalPath) {
-                            symlinkCache.setSymlinkedDirectoryFromSymlinkedFile(originalPath, resolvedFileName);
                         }
-                        if (!program.getSourceFile(resolvedFileName) && (!originalPath || !program.getSourceFile(originalPath))) {
-                            rootNames = ts.append(rootNames, resolvedFileName);
-                            // Avoid creating a large project that would significantly slow down time to editor interactivity
-                            if (dependencySelection === 2 /* Auto */ && rootNames.length > this.maxDependencies) {
-                                return ts.emptyArray;
-                            }
+                        // 3. If the @types package did not exist and the user has settings that
+                        //    allow processing JS from node_modules, go back to the implementation
+                        //    package and load the JS.
+                        if (packageJson && compilerOptions.allowJs && compilerOptions.maxNodeModuleJsDepth) {
+                            var entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache, /*allowJs*/ true);
+                            rootNames = ts.concatenate(rootNames, entrypoints);
+                            dependenciesAdded += (entrypoints === null || entrypoints === void 0 ? void 0 : entrypoints.length) ? 1 : 0;
                         }
                     }
                 }
@@ -166219,6 +166494,26 @@ var ts;
                         (dependencyNames || (dependencyNames = new ts.Set())).add(dependency);
                     }
                 }
+                function getRootNamesFromPackageJson(packageJson, program, symlinkCache, resolveJs) {
+                    var _a;
+                    var entrypoints = ts.getEntrypointsFromPackageJsonInfo(packageJson, compilerOptions, moduleResolutionHost, program.getModuleResolutionCache(), resolveJs);
+                    if (entrypoints) {
+                        var real_1 = (_a = moduleResolutionHost.realpath) === null || _a === void 0 ? void 0 : _a.call(moduleResolutionHost, packageJson.packageDirectory);
+                        var isSymlink_1 = real_1 && real_1 !== packageJson.packageDirectory;
+                        if (isSymlink_1) {
+                            symlinkCache.setSymlinkedDirectory(packageJson.packageDirectory, {
+                                real: real_1,
+                                realPath: hostProject.toPath(real_1),
+                            });
+                        }
+                        return ts.mapDefined(entrypoints, function (entrypoint) {
+                            var resolvedFileName = isSymlink_1 ? entrypoint.replace(packageJson.packageDirectory, real_1) : entrypoint;
+                            if (!program.getSourceFile(resolvedFileName) && !(isSymlink_1 && program.getSourceFile(entrypoint))) {
+                                return resolvedFileName;
+                            }
+                        });
+                    }
+                }
             };
             /*@internal*/
             AutoImportProviderProject.create = function (dependencySelection, hostProject, moduleResolutionHost, documentRegistry) {
@@ -171233,6 +171528,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);
@@ -171984,7 +172282,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 */)
@@ -175272,12 +175570,40 @@ var ts;
                 };
                 return IOSession;
             }(server.Session));
+            var IpcIOSession = /** @class */ (function (_super) {
+                __extends(IpcIOSession, _super);
+                function IpcIOSession() {
+                    return _super !== null && _super.apply(this, arguments) || this;
+                }
+                IpcIOSession.prototype.writeMessage = function (msg) {
+                    var verboseLogging = logger.hasLevel(server.LogLevel.verbose);
+                    if (verboseLogging) {
+                        var json = JSON.stringify(msg);
+                        logger.info(msg.type + ":" + server.indent(json));
+                    }
+                    process.send(msg);
+                };
+                IpcIOSession.prototype.parseMessage = function (message) {
+                    return message;
+                };
+                IpcIOSession.prototype.toStringMessage = function (message) {
+                    return JSON.stringify(message, undefined, 2);
+                };
+                IpcIOSession.prototype.listen = function () {
+                    var _this = this;
+                    process.on("message", function (e) {
+                        _this.onMessage(e);
+                    });
+                };
+                return IpcIOSession;
+            }(IOSession));
             var eventPort = parseEventPort(server.findArgument("--eventPort"));
             var typingSafeListLocation = server.findArgument(server.Arguments.TypingSafeListLocation); // TODO: GH#18217
             var typesMapLocation = server.findArgument(server.Arguments.TypesMapLocation) || ts.combinePaths(ts.getDirectoryPath(ts.sys.getExecutingFilePath()), "typesMap.json");
             var npmLocation = server.findArgument(server.Arguments.NpmLocation);
             var validateDefaultNpmLocation = server.hasArgument(server.Arguments.ValidateDefaultNpmLocation);
             var disableAutomaticTypingAcquisition = server.hasArgument("--disableAutomaticTypingAcquisition");
+            var useNodeIpc = server.hasArgument("--useNodeIpc");
             var telemetryEnabled = server.hasArgument(server.Arguments.EnableTelemetry);
             var commandLineTraceDir = server.findArgument("--traceDirectory");
             var traceDir = commandLineTraceDir
@@ -175286,7 +175612,7 @@ var ts;
             if (traceDir) {
                 ts.startTracing("server", traceDir);
             }
-            var ioSession = new IOSession();
+            var ioSession = useNodeIpc ? new IpcIOSession() : new IOSession();
             process.on("uncaughtException", function (err) {
                 ioSession.logError(err, "unknown");
             });