typescript 4.5.0-dev.20211025 → 4.5.0-dev.20211029

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-dev.20211025";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211029";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2551,6 +2551,10 @@ var ts;
             return formatEnum(kind, ts.SyntaxKind, /*isFlags*/ false);
         }
         Debug.formatSyntaxKind = formatSyntaxKind;
+        function formatSnippetKind(kind) {
+            return formatEnum(kind, ts.SnippetKind, /*isFlags*/ false);
+        }
+        Debug.formatSnippetKind = formatSnippetKind;
         function formatNodeFlags(flags) {
             return formatEnum(flags, ts.NodeFlags, /*isFlags*/ true);
         }
@@ -4467,6 +4471,13 @@ var ts;
         ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped";
     })(ExitStatus = ts.ExitStatus || (ts.ExitStatus = {}));
     /* @internal */
+    var MemberOverrideStatus;
+    (function (MemberOverrideStatus) {
+        MemberOverrideStatus[MemberOverrideStatus["Ok"] = 0] = "Ok";
+        MemberOverrideStatus[MemberOverrideStatus["NeedsOverride"] = 1] = "NeedsOverride";
+        MemberOverrideStatus[MemberOverrideStatus["HasInvalidOverride"] = 2] = "HasInvalidOverride";
+    })(MemberOverrideStatus = ts.MemberOverrideStatus || (ts.MemberOverrideStatus = {}));
+    /* @internal */
     var UnionReduction;
     (function (UnionReduction) {
         UnionReduction[UnionReduction["None"] = 0] = "None";
@@ -5448,6 +5459,15 @@ var ts;
         // Masks
         // - Additional bitmasks
     })(TransformFlags = ts.TransformFlags || (ts.TransformFlags = {}));
+    // Reference: https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax
+    /* @internal */
+    var SnippetKind;
+    (function (SnippetKind) {
+        SnippetKind[SnippetKind["TabStop"] = 0] = "TabStop";
+        SnippetKind[SnippetKind["Placeholder"] = 1] = "Placeholder";
+        SnippetKind[SnippetKind["Choice"] = 2] = "Choice";
+        SnippetKind[SnippetKind["Variable"] = 3] = "Variable";
+    })(SnippetKind = ts.SnippetKind || (ts.SnippetKind = {}));
     var EmitFlags;
     (function (EmitFlags) {
         EmitFlags[EmitFlags["None"] = 0] = "None";
@@ -9343,6 +9363,7 @@ var ts;
         This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: diag(7059, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."),
         This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: diag(7060, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."),
         A_mapped_type_may_not_declare_properties_or_methods: diag(7061, ts.DiagnosticCategory.Error, "A_mapped_type_may_not_declare_properties_or_methods_7061", "A mapped type may not declare properties or methods."),
+        JSON_imports_are_experimental_in_ES_module_mode_imports: diag(7062, ts.DiagnosticCategory.Error, "JSON_imports_are_experimental_in_ES_module_mode_imports_7062", "JSON imports are experimental in ES module mode imports."),
         You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."),
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."),
         import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."),
@@ -19639,6 +19660,8 @@ var ts;
             case ts.ModuleKind.ES2020:
             case ts.ModuleKind.ES2022:
             case ts.ModuleKind.ESNext:
+            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.NodeNext:
                 return true;
             default:
                 return false;
@@ -20750,6 +20773,10 @@ var ts;
         return node.kind === 212 /* FunctionExpression */ || node.kind === 213 /* ArrowFunction */;
     }
     ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
+    function escapeSnippetText(text) {
+        return text.replace(/\$/gm, "\\$");
+    }
+    ts.escapeSnippetText = escapeSnippetText;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -26953,6 +26980,25 @@ var ts;
         }
     }
     ts.moveEmitHelpers = moveEmitHelpers;
+    /**
+     * Gets the SnippetElement of a node.
+     */
+    /* @internal */
+    function getSnippetElement(node) {
+        var _a;
+        return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.snippetElement;
+    }
+    ts.getSnippetElement = getSnippetElement;
+    /**
+     * Sets the SnippetElement of a node.
+     */
+    /* @internal */
+    function setSnippetElement(node, snippet) {
+        var emitNode = getOrCreateEmitNode(node);
+        emitNode.snippetElement = snippet;
+        return node;
+    }
+    ts.setSnippetElement = setSnippetElement;
     /* @internal */
     function ignoreSourceNewlines(node) {
         getOrCreateEmitNode(node).flags |= 134217728 /* IgnoreSourceNewlines */;
@@ -47078,6 +47124,7 @@ var ts;
             isDeclarationVisible: isDeclarationVisible,
             isPropertyAccessible: isPropertyAccessible,
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
+            getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
         };
         function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -48824,6 +48871,10 @@ var ts;
         function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
             return usageMode === ts.ModuleKind.ESNext && targetMode === ts.ModuleKind.CommonJS;
         }
+        function isOnlyImportedAsDefault(usage) {
+            var usageMode = getUsageModeForExpression(usage);
+            return usageMode === ts.ModuleKind.ESNext && ts.endsWith(usage.text, ".json" /* Json */);
+        }
         function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
             var usageMode = file && getUsageModeForExpression(usage);
             if (file && usageMode !== undefined) {
@@ -48874,8 +48925,9 @@ var ts;
                     exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, node, dontResolveAlias);
                 }
                 var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
+                var hasDefaultOnly = isOnlyImportedAsDefault(node.parent.moduleSpecifier);
                 var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, node.parent.moduleSpecifier);
-                if (!exportDefaultSymbol && !hasSyntheticDefault) {
+                if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) {
                     if (hasExportAssignmentSymbol(moduleSymbol)) {
                         var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop";
                         var exportEqualsSymbol = moduleSymbol.exports.get("export=" /* ExportEquals */);
@@ -48889,7 +48941,7 @@ var ts;
                         reportNonDefaultExport(moduleSymbol, node);
                     }
                 }
-                else if (hasSyntheticDefault) {
+                else if (hasSyntheticDefault || hasDefaultOnly) {
                     // per emit behavior, a synthetic default overrides a "real" .default member if `__esModule` is not present
                     var resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                     markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, /*overwriteTypeOnly*/ false);
@@ -49014,7 +49066,7 @@ var ts;
                     var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
                     if (symbolFromModule === undefined && name.escapedText === "default" /* Default */) {
                         var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                        if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
+                        if (isOnlyImportedAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
                             symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                         }
                     }
@@ -49408,21 +49460,28 @@ var ts;
                         var namespaceName = getFullyQualifiedName(namespace);
                         var declarationName = ts.declarationNameToString(right);
                         var suggestionForNonexistentModule = getSuggestedSymbolForNonexistentModule(right, namespace);
-                        var exportedTypeSymbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, 788968 /* Type */));
-                        var containingQualifiedName = ts.isQualifiedName(name) && getContainingQualifiedNameNode(name);
-                        var canSuggestTypeof = containingQualifiedName && !ts.isTypeOfExpression(containingQualifiedName.parent) && tryGetQualifiedNameAsValue(containingQualifiedName);
                         if (suggestionForNonexistentModule) {
                             error(right, ts.Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, namespaceName, declarationName, symbolToString(suggestionForNonexistentModule));
+                            return undefined;
                         }
-                        else if (canSuggestTypeof) {
+                        var containingQualifiedName = ts.isQualifiedName(name) && getContainingQualifiedNameNode(name);
+                        var canSuggestTypeof = globalObjectType // <-- can't pull on types if global types aren't initialized yet
+                            && (meaning & 788968 /* Type */)
+                            && containingQualifiedName
+                            && !ts.isTypeOfExpression(containingQualifiedName.parent)
+                            && tryGetQualifiedNameAsValue(containingQualifiedName);
+                        if (canSuggestTypeof) {
                             error(containingQualifiedName, ts.Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, ts.entityNameToString(containingQualifiedName));
+                            return undefined;
                         }
-                        else if (meaning & 1920 /* Namespace */ && exportedTypeSymbol && ts.isQualifiedName(name.parent)) {
-                            error(name.parent.right, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, symbolToString(exportedTypeSymbol), ts.unescapeLeadingUnderscores(name.parent.right.escapedText));
-                        }
-                        else {
-                            error(right, ts.Diagnostics.Namespace_0_has_no_exported_member_1, namespaceName, declarationName);
+                        if (meaning & 1920 /* Namespace */ && ts.isQualifiedName(name.parent)) {
+                            var exportedTypeSymbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, 788968 /* Type */));
+                            if (exportedTypeSymbol) {
+                                error(name.parent.right, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, symbolToString(exportedTypeSymbol), ts.unescapeLeadingUnderscores(name.parent.right.escapedText));
+                                return undefined;
+                            }
                         }
+                        error(right, ts.Diagnostics.Namespace_0_has_no_exported_member_1, namespaceName, declarationName);
                     }
                     return undefined;
                 }
@@ -49558,6 +49617,9 @@ var ts;
                         if (isSyncImport && sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) {
                             error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead, moduleReference);
                         }
+                        if (mode === ts.ModuleKind.ESNext && compilerOptions.resolveJsonModule && resolvedModule.extension === ".json" /* Json */) {
+                            error(errorNode, ts.Diagnostics.JSON_imports_are_experimental_in_ES_module_mode_imports);
+                        }
                     }
                     // merged symbol is module declaration symbol combined with all augmentations
                     return getMergedSymbol(sourceFile.symbol);
@@ -49696,40 +49758,50 @@ var ts;
                     error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName);
                     return symbol;
                 }
-                if (ts.getESModuleInterop(compilerOptions)) {
-                    var referenceParent = referencingLocation.parent;
-                    if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
-                        ts.isImportCall(referenceParent)) {
-                        var type = getTypeOfSymbol(symbol);
+                var referenceParent = referencingLocation.parent;
+                if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
+                    ts.isImportCall(referenceParent)) {
+                    var reference = ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier;
+                    var type = getTypeOfSymbol(symbol);
+                    var defaultOnlyType = getTypeWithSyntheticDefaultOnly(type, symbol, moduleSymbol, reference);
+                    if (defaultOnlyType) {
+                        return cloneTypeAsModuleType(symbol, defaultOnlyType, referenceParent);
+                    }
+                    if (ts.getESModuleInterop(compilerOptions)) {
                         var sigs = getSignaturesOfStructuredType(type, 0 /* Call */);
                         if (!sigs || !sigs.length) {
                             sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
                         }
-                        if (sigs && sigs.length) {
-                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier);
-                            // Create a new symbol which has the module's type less the call and construct signatures
-                            var result = createSymbol(symbol.flags, symbol.escapedName);
-                            result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
-                            result.parent = symbol.parent;
-                            result.target = symbol;
-                            result.originatingImport = referenceParent;
-                            if (symbol.valueDeclaration)
-                                result.valueDeclaration = symbol.valueDeclaration;
-                            if (symbol.constEnumOnlyModule)
-                                result.constEnumOnlyModule = true;
-                            if (symbol.members)
-                                result.members = new ts.Map(symbol.members);
-                            if (symbol.exports)
-                                result.exports = new ts.Map(symbol.exports);
-                            var resolvedModuleType = resolveStructuredTypeMembers(moduleType); // Should already be resolved from the signature checks above
-                            result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.indexInfos);
-                            return result;
+                        if ((sigs && sigs.length) || getPropertyOfType(type, "default" /* Default */)) {
+                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference);
+                            return cloneTypeAsModuleType(symbol, moduleType, referenceParent);
                         }
                     }
                 }
             }
             return symbol;
         }
+        /**
+         * Create a new symbol which has the module's type less the call and construct signatures
+         */
+        function cloneTypeAsModuleType(symbol, moduleType, referenceParent) {
+            var result = createSymbol(symbol.flags, symbol.escapedName);
+            result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
+            result.parent = symbol.parent;
+            result.target = symbol;
+            result.originatingImport = referenceParent;
+            if (symbol.valueDeclaration)
+                result.valueDeclaration = symbol.valueDeclaration;
+            if (symbol.constEnumOnlyModule)
+                result.constEnumOnlyModule = true;
+            if (symbol.members)
+                result.members = new ts.Map(symbol.members);
+            if (symbol.exports)
+                result.exports = new ts.Map(symbol.exports);
+            var resolvedModuleType = resolveStructuredTypeMembers(moduleType); // Should already be resolved from the signature checks above
+            result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.indexInfos);
+            return result;
+        }
         function hasExportAssignmentSymbol(moduleSymbol) {
             return moduleSymbol.exports.get("export=" /* ExportEquals */) !== undefined;
         }
@@ -59335,7 +59407,7 @@ var ts;
                 var _loop_16 = function () {
                     i--;
                     var t = types[i];
-                    if (t.flags & 128 /* StringLiteral */ && ts.some(templates, function (template) { return isTypeSubtypeOf(t, template); })) {
+                    if (t.flags & 128 /* StringLiteral */ && ts.some(templates, function (template) { return isTypeMatchedByTemplateLiteralType(t, template); })) {
                         ts.orderedRemoveItemAt(types, i);
                     }
                 };
@@ -61528,7 +61600,8 @@ var ts;
                     return mapTypeWithAlias(getReducedType(mappedTypeVariable), function (t) {
                         if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
                             if (!type.declaration.nameType) {
-                                if (isArrayType(t)) {
+                                var constraint = void 0;
+                                if (isArrayType(t) || (t.flags & 1 /* Any */) && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, ts.or(isArrayType, isTupleType))) {
                                     return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
                                 }
                                 if (isGenericTupleType(t)) {
@@ -63068,13 +63141,12 @@ var ts;
                 traceUnionsOrIntersectionsTooLarge(source, target);
                 var result = 0 /* False */;
                 var saveErrorInfo = captureErrorCalculationState();
-                // Note that these checks are specifically ordered to produce correct results. In particular,
-                // we need to deconstruct unions before intersections (because unions are always at the top),
-                // and we need to handle "each" relations before "some" relations for the same kind of type.
-                if (source.flags & 3145728 /* UnionOrIntersection */ || target.flags & 3145728 /* UnionOrIntersection */) {
-                    result = getConstituentCount(source) * getConstituentCount(target) >= 4 ?
-                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */, recursionFlags) :
-                        structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */);
+                if ((source.flags & 1048576 /* Union */ || target.flags & 1048576 /* Union */) && getConstituentCount(source) * getConstituentCount(target) < 4) {
+                    // We skip caching when source or target is a union with no more than three constituents.
+                    result = structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */);
+                }
+                else if (source.flags & 3145728 /* UnionOrIntersection */ || target.flags & 3145728 /* UnionOrIntersection */) {
+                    result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */, recursionFlags);
                 }
                 if (!result && !(source.flags & 1048576 /* Union */) && (source.flags & (469499904 /* StructuredOrInstantiable */) || target.flags & 469499904 /* StructuredOrInstantiable */)) {
                     if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags)) {
@@ -63531,19 +63603,19 @@ var ts;
                 var maybeStart = maybeCount;
                 maybeKeys[maybeCount] = id;
                 maybeCount++;
+                var saveExpandingFlags = expandingFlags;
                 if (recursionFlags & 1 /* Source */) {
                     sourceStack[sourceDepth] = source;
                     sourceDepth++;
+                    if (!(expandingFlags & 1 /* Source */) && isDeeplyNestedType(source, sourceStack, sourceDepth))
+                        expandingFlags |= 1 /* Source */;
                 }
                 if (recursionFlags & 2 /* Target */) {
                     targetStack[targetDepth] = target;
                     targetDepth++;
+                    if (!(expandingFlags & 2 /* Target */) && isDeeplyNestedType(target, targetStack, targetDepth))
+                        expandingFlags |= 2 /* Target */;
                 }
-                var saveExpandingFlags = expandingFlags;
-                if (!(expandingFlags & 1 /* Source */) && isDeeplyNestedType(source, sourceStack, sourceDepth))
-                    expandingFlags |= 1 /* Source */;
-                if (!(expandingFlags & 2 /* Target */) && isDeeplyNestedType(target, targetStack, targetDepth))
-                    expandingFlags |= 2 /* Target */;
                 var originalHandler;
                 var propagatingVarianceFlags = 0;
                 if (outofbandVarianceMarkerHandler) {
@@ -63567,13 +63639,13 @@ var ts;
                 if (outofbandVarianceMarkerHandler) {
                     outofbandVarianceMarkerHandler = originalHandler;
                 }
-                expandingFlags = saveExpandingFlags;
                 if (recursionFlags & 1 /* Source */) {
                     sourceDepth--;
                 }
                 if (recursionFlags & 2 /* Target */) {
                     targetDepth--;
                 }
+                expandingFlags = saveExpandingFlags;
                 if (result) {
                     if (result === -1 /* True */ || (sourceDepth === 0 && targetDepth === 0)) {
                         if (result === -1 /* True */ || result === 3 /* Maybe */) {
@@ -63911,8 +63983,7 @@ var ts;
                         // For example, `foo-${number}` is related to `foo-${string}` even though number isn't related to string.
                         instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
                     }
-                    var result_9 = inferTypesFromTemplateLiteralType(source, target);
-                    if (result_9 && ts.every(result_9, function (r, i) { return isValidTypeForTemplateLiteralPlaceholder(r, target.types[i]); })) {
+                    if (isTypeMatchedByTemplateLiteralType(source, target)) {
                         return -1 /* True */;
                     }
                 }
@@ -64107,9 +64178,9 @@ var ts;
                     if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */) && target.flags & 1048576 /* Union */) {
                         var objectOnlyTarget = extractTypesOfKind(target, 524288 /* Object */ | 2097152 /* Intersection */ | 33554432 /* Substitution */);
                         if (objectOnlyTarget.flags & 1048576 /* Union */) {
-                            var result_10 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
-                            if (result_10) {
-                                return result_10;
+                            var result_9 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
+                            if (result_9) {
+                                return result_9;
                             }
                         }
                     }
@@ -64181,13 +64252,13 @@ var ts;
                 var modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source) === getMappedTypeModifiers(target) :
                     getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target));
                 if (modifiersRelated) {
-                    var result_11;
+                    var result_10;
                     var targetConstraint = getConstraintTypeFromMappedType(target);
                     var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), makeFunctionTypeMapper(getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMarkers : reportUnreliableMarkers));
-                    if (result_11 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors)) {
+                    if (result_10 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors)) {
                         var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
                         if (instantiateType(getNameTypeFromMappedType(source), mapper) === instantiateType(getNameTypeFromMappedType(target), mapper)) {
-                            return result_11 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), 3 /* Both */, reportErrors);
+                            return result_10 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), 3 /* Both */, reportErrors);
                         }
                     }
                 }
@@ -66270,6 +66341,10 @@ var ts;
                         inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) :
                     undefined;
         }
+        function isTypeMatchedByTemplateLiteralType(source, target) {
+            var inferences = inferTypesFromTemplateLiteralType(source, target);
+            return !!inferences && ts.every(inferences, function (r, i) { return isValidTypeForTemplateLiteralPlaceholder(r, target.types[i]); });
+        }
         function getStringLikeTypeForType(type) {
             return type.flags & (1 /* Any */ | 402653316 /* StringLike */) ? type : getTemplateLiteralType(["", ""], [type]);
         }
@@ -67173,8 +67248,11 @@ var ts;
         function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
             switch (node.kind) {
                 case 79 /* Identifier */:
-                    var symbol = getResolvedSymbol(node);
-                    return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + getSymbolId(symbol) : undefined;
+                    if (!ts.isThisInTypeQuery(node)) {
+                        var symbol = getResolvedSymbol(node);
+                        return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + getSymbolId(symbol) : undefined;
+                    }
+                // falls through
                 case 108 /* ThisKeyword */:
                     return "0|" + (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType);
                 case 229 /* NonNullExpression */:
@@ -67805,7 +67883,7 @@ var ts;
                 mapType(type, mapper);
         }
         function getConstituentCount(type) {
-            return type.flags & 3145728 /* UnionOrIntersection */ ? type.types.length : 1;
+            return type.flags & 1048576 /* Union */ ? type.types.length : 1;
         }
         function extractTypesOfKind(type, kind) {
             return filterType(type, function (t) { return (t.flags & kind) !== 0; });
@@ -69303,7 +69381,7 @@ var ts;
             return parent.kind === 205 /* PropertyAccessExpression */ ||
                 parent.kind === 207 /* CallExpression */ && parent.expression === node ||
                 parent.kind === 206 /* ElementAccessExpression */ && parent.expression === node &&
-                    !(isGenericTypeWithoutNullableConstraint(type) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
+                    !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
         }
         function isGenericTypeWithUnionConstraint(type) {
             return !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
@@ -74903,11 +74981,33 @@ var ts;
             if (moduleSymbol) {
                 var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, /*dontRecursivelyResolve*/ true, /*suppressUsageError*/ false);
                 if (esModuleSymbol) {
-                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
+                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultOnly(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier) ||
+                        getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
                 }
             }
             return createPromiseReturnType(node, anyType);
         }
+        function createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol) {
+            var memberTable = ts.createSymbolTable();
+            var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
+            newSymbol.parent = originalSymbol;
+            newSymbol.nameType = getStringLiteralType("default");
+            newSymbol.target = resolveSymbol(symbol);
+            memberTable.set("default" /* Default */, newSymbol);
+            return createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+        }
+        function getTypeWithSyntheticDefaultOnly(type, symbol, originalSymbol, moduleSpecifier) {
+            var hasDefaultOnly = isOnlyImportedAsDefault(moduleSpecifier);
+            if (hasDefaultOnly && type && !isErrorType(type)) {
+                var synthType = type;
+                if (!synthType.defaultOnlyType) {
+                    var type_4 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
+                    synthType.defaultOnlyType = type_4;
+                }
+                return synthType.defaultOnlyType;
+            }
+            return undefined;
+        }
         function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) {
             var _a;
             if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
@@ -74916,14 +75016,8 @@ var ts;
                     var file = (_a = originalSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
                     var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false, moduleSpecifier);
                     if (hasSyntheticDefault) {
-                        var memberTable = ts.createSymbolTable();
-                        var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
-                        newSymbol.parent = originalSymbol;
-                        newSymbol.nameType = getStringLiteralType("default");
-                        newSymbol.target = resolveSymbol(symbol);
-                        memberTable.set("default" /* Default */, newSymbol);
                         var anonymousSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
-                        var defaultContainingObject = createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+                        var defaultContainingObject = createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol);
                         anonymousSymbol.type = defaultContainingObject;
                         synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, /*objectFlags*/ 0, /*readonly*/ false) : defaultContainingObject;
                     }
@@ -75631,12 +75725,12 @@ var ts;
                 var witnesses = getSwitchClauseTypeOfWitnesses(node, /*retainDefault*/ false);
                 // notEqualFacts states that the type of the switched value is not equal to every type in the switch.
                 var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, /*hasDefault*/ true);
-                var type_4 = getBaseConstraintOfType(operandType) || operandType;
+                var type_5 = getBaseConstraintOfType(operandType) || operandType;
                 // Take any/unknown as a special condition. Or maybe we could change `type` to a union containing all primitive types.
-                if (type_4.flags & 3 /* AnyOrUnknown */) {
+                if (type_5.flags & 3 /* AnyOrUnknown */) {
                     return (556800 /* AllTypeofNE */ & notEqualFacts_1) === 556800 /* AllTypeofNE */;
                 }
-                return !!(filterType(type_4, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
+                return !!(filterType(type_5, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
             }
             var type = getTypeOfExpression(node.expression);
             if (!isLiteralType(type)) {
@@ -78732,12 +78826,12 @@ var ts;
                     case 264 /* ImportEqualsDeclaration */:
                     case 267 /* NamespaceImport */:
                     case 266 /* ImportClause */:
-                        var result_12 = 0 /* None */;
+                        var result_11 = 0 /* None */;
                         var target = resolveAlias(getSymbolOfNode(d));
                         ts.forEach(target.declarations, function (d) {
-                            result_12 |= getDeclarationSpaces(d);
+                            result_11 |= getDeclarationSpaces(d);
                         });
-                        return result_12;
+                        return result_11;
                     case 253 /* VariableDeclaration */:
                     case 202 /* BindingElement */:
                     case 255 /* FunctionDeclaration */:
@@ -81606,7 +81700,7 @@ var ts;
                     checkKindsOfPropertyMemberOverrides(type, baseType_1);
                 }
             }
-            checkMembersForMissingOverrideModifier(node, type, typeWithThis, staticType);
+            checkMembersForOverrideModifier(node, type, typeWithThis, staticType);
             var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node);
             if (implementedTypeNodes) {
                 for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
@@ -81641,8 +81735,7 @@ var ts;
                 checkPropertyInitialization(node);
             }
         }
-        function checkMembersForMissingOverrideModifier(node, type, typeWithThis, staticType) {
-            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+        function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) {
             var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
@@ -81654,46 +81747,71 @@ var ts;
                 if (ts.isConstructorDeclaration(member)) {
                     ts.forEach(member.parameters, function (param) {
                         if (ts.isParameterPropertyDeclaration(param, member)) {
-                            checkClassMember(param, /*memberIsParameterProperty*/ true);
+                            checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, param, 
+                            /* memberIsParameterProperty */ true);
                         }
                     });
                 }
-                checkClassMember(member);
+                checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, 
+                /* memberIsParameterProperty */ false);
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
                 _loop_29(member);
             }
-            function checkClassMember(member, memberIsParameterProperty) {
-                var hasOverride = ts.hasOverrideModifier(member);
-                var hasStatic = ts.isStatic(member);
-                var isJs = ts.isInJSFile(member);
-                if (baseWithThis && (hasOverride || compilerOptions.noImplicitOverride)) {
-                    var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
-                    if (!declaredProp) {
-                        return;
-                    }
-                    var thisType = hasStatic ? staticType : typeWithThis;
-                    var baseType = hasStatic ? baseStaticType : baseWithThis;
-                    var prop = getPropertyOfType(thisType, declaredProp.escapedName);
-                    var baseProp = getPropertyOfType(baseType, declaredProp.escapedName);
-                    var baseClassName = typeToString(baseWithThis);
-                    if (prop && !baseProp && hasOverride) {
-                        var suggestion = getSuggestedSymbolForNonexistentClassMember(ts.symbolName(declaredProp), baseType);
+        }
+        /**
+         * @param member Existing member node to be checked.
+         * Note: `member` cannot be a synthetic node.
+         */
+        function checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, memberIsParameterProperty, reportErrors) {
+            if (reportErrors === void 0) { reportErrors = true; }
+            var declaredProp = member.name
+                && getSymbolAtLocation(member.name)
+                || getSymbolAtLocation(member);
+            if (!declaredProp) {
+                return 0 /* Ok */;
+            }
+            return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, ts.hasOverrideModifier(member), ts.hasAbstractModifier(member), ts.isStatic(member), memberIsParameterProperty, ts.symbolName(declaredProp), reportErrors ? member : undefined);
+        }
+        /**
+         * Checks a class member declaration for either a missing or an invalid `override` modifier.
+         * Note: this function can be used for speculative checking,
+         * i.e. checking a member that does not yet exist in the program.
+         * An example of that would be to call this function in a completions scenario,
+         * when offering a method declaration as completion.
+         * @param errorNode The node where we should report an error, or undefined if we should not report errors.
+         */
+        function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) {
+            var isJs = ts.isInJSFile(node);
+            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+            if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
+                var memberEscapedName = ts.escapeLeadingUnderscores(memberName);
+                var thisType = memberIsStatic ? staticType : typeWithThis;
+                var baseType = memberIsStatic ? baseStaticType : baseWithThis;
+                var prop = getPropertyOfType(thisType, memberEscapedName);
+                var baseProp = getPropertyOfType(baseType, memberEscapedName);
+                var baseClassName = typeToString(baseWithThis);
+                if (prop && !baseProp && memberHasOverrideModifier) {
+                    if (errorNode) {
+                        var suggestion = getSuggestedSymbolForNonexistentClassMember(memberName, baseType); // Again, using symbol name: note that's different from `symbol.escapedName`
                         suggestion ?
-                            error(member, isJs ?
+                            error(errorNode, isJs ?
                                 ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 :
                                 ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1, baseClassName, symbolToString(suggestion)) :
-                            error(member, isJs ?
+                            error(errorNode, isJs ?
                                 ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 :
                                 ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0, baseClassName);
                     }
-                    else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
-                        var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier);
-                        if (hasOverride) {
-                            return;
-                        }
-                        if (!baseHasAbstract) {
+                    return 2 /* HasInvalidOverride */;
+                }
+                else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
+                    var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier);
+                    if (memberHasOverrideModifier) {
+                        return 0 /* Ok */;
+                    }
+                    if (!baseHasAbstract) {
+                        if (errorNode) {
                             var diag = memberIsParameterProperty ?
                                 isJs ?
                                     ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 :
@@ -81701,20 +81819,28 @@ var ts;
                                 isJs ?
                                     ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 :
                                     ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0;
-                            error(member, diag, baseClassName);
+                            error(errorNode, diag, baseClassName);
                         }
-                        else if (ts.hasAbstractModifier(member) && baseHasAbstract) {
-                            error(member, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
+                        return 1 /* NeedsOverride */;
+                    }
+                    else if (memberHasAbstractModifier && baseHasAbstract) {
+                        if (errorNode) {
+                            error(errorNode, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
                         }
+                        return 1 /* NeedsOverride */;
                     }
                 }
-                else if (hasOverride) {
+            }
+            else if (memberHasOverrideModifier) {
+                if (errorNode) {
                     var className = typeToString(type);
-                    error(member, isJs ?
+                    error(errorNode, isJs ?
                         ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class :
                         ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class, className);
                 }
+                return 2 /* HasInvalidOverride */;
             }
+            return 0 /* Ok */;
         }
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
@@ -81757,6 +81883,31 @@ var ts;
                 }
             }
         }
+        /**
+         * Checks a member declaration node to see if has a missing or invalid `override` modifier.
+         * @param node Class-like node where the member is declared.
+         * @param member Member declaration node.
+         * Note: `member` can be a synthetic node without a parent.
+         */
+        function getMemberOverrideModifierStatus(node, member) {
+            if (!member.name) {
+                return 0 /* Ok */;
+            }
+            var symbol = getSymbolOfNode(node);
+            var type = getDeclaredTypeOfSymbol(symbol);
+            var typeWithThis = getTypeWithThisArgument(type);
+            var staticType = getTypeOfSymbol(symbol);
+            var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
+            var baseTypes = baseTypeNode && getBaseTypes(type);
+            var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
+            var baseStaticType = getBaseConstructorTypeOfClass(type);
+            var memberHasOverrideModifier = member.parent
+                ? ts.hasOverrideModifier(member)
+                : ts.hasSyntacticModifier(member, 16384 /* Override */);
+            var memberName = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(member.name));
+            return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, ts.hasAbstractModifier(member), ts.isStatic(member), 
+            /* memberIsParameterProperty */ false, memberName);
+        }
         function getTargetSymbol(s) {
             // if symbol is instantiated its flags are not copied from the 'target'
             // so we'll need to get back original 'target' symbol to work with correct set of flags
@@ -94910,8 +95061,8 @@ var ts;
         function convertJsxChildrenToChildrenPropAssignment(children) {
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
             if (ts.length(nonWhitespaceChildren) === 1) {
-                var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
-                return result_13 && factory.createPropertyAssignment("children", result_13);
+                var result_12 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
+                return result_12 && factory.createPropertyAssignment("children", result_12);
             }
             var result = ts.mapDefined(children, transformJsxChildToExpression);
             return ts.length(result) ? factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result)) : undefined;
@@ -108061,7 +108212,14 @@ var ts;
             // clear the parenthesizer rule as we ascend
             currentParenthesizerRule = undefined;
         }
-        function pipelineEmitWithHintWorker(hint, node) {
+        function pipelineEmitWithHintWorker(hint, node, allowSnippets) {
+            if (allowSnippets === void 0) { allowSnippets = true; }
+            if (allowSnippets) {
+                var snippet = ts.getSnippetElement(node);
+                if (snippet) {
+                    return emitSnippetNode(hint, node, snippet);
+                }
+            }
             if (hint === 0 /* SourceFile */)
                 return emitSourceFile(ts.cast(node, ts.isSourceFile));
             if (hint === 2 /* IdentifierName */)
@@ -108670,6 +108828,28 @@ var ts;
             }
         }
         //
+        // Snippet Elements
+        //
+        function emitSnippetNode(hint, node, snippet) {
+            switch (snippet.kind) {
+                case 1 /* Placeholder */:
+                    emitPlaceholder(hint, node, snippet);
+                    break;
+                case 0 /* TabStop */:
+                    emitTabStop(snippet);
+                    break;
+            }
+        }
+        function emitPlaceholder(hint, node, snippet) {
+            nonEscapingWrite("${" + snippet.order + ":"); // `${2:`
+            pipelineEmitWithHintWorker(hint, node, /*allowSnippets*/ false); // `...`
+            nonEscapingWrite("}"); // `}`
+            // `${2:...}`
+        }
+        function emitTabStop(snippet) {
+            nonEscapingWrite("$" + snippet.order);
+        }
+        //
         // Identifiers
         //
         function emitIdentifier(node) {
@@ -110908,6 +111088,15 @@ var ts;
         function writeProperty(s) {
             writer.writeProperty(s);
         }
+        function nonEscapingWrite(s) {
+            // This should be defined in a snippet-escaping text writer.
+            if (writer.nonEscapingWrite) {
+                writer.nonEscapingWrite(s);
+            }
+            else {
+                writer.write(s);
+            }
+        }
         function writeLine(count) {
             if (count === void 0) { count = 1; }
             for (var i = 0; i < count; i++) {
@@ -113711,15 +113900,15 @@ var ts;
                 // which per above occurred during the current program creation.
                 // Since we assume the filesystem does not change during program creation,
                 // it is safe to reuse resolutions from the earlier call.
-                var result_14 = [];
+                var result_13 = [];
                 var i = 0;
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
                     var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i));
                     i++;
-                    result_14.push(resolvedModule);
+                    result_13.push(resolvedModule);
                 }
-                return result_14;
+                return result_13;
             }
             // At this point, we know at least one of the following hold:
             // - file has local declarations for ambient modules
@@ -115448,7 +115637,9 @@ var ts;
                 }
             }
             if (options.resolveJsonModule) {
-                if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs) {
+                if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs &&
+                    ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node12 &&
+                    ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
                     createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule");
                 }
                 // Any emit other than common js, amd, es2015 or esnext is error
@@ -118781,9 +118972,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_15)
-                    return result_15;
+                var result_14 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_14)
+                    return result_14;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -118803,10 +118994,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_16 = cb(option, target === referenceRedirect);
+                        var result_15 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_16)
-                            return result_16;
+                        if (result_15)
+                            return result_15;
                     }
                 });
             });
@@ -125543,6 +125734,10 @@ var ts;
         return decisionFromFile !== null && decisionFromFile !== void 0 ? decisionFromFile : program.usesUriStyleNodeCoreModules;
     }
     ts.shouldUseUriStyleNodeCoreModules = shouldUseUriStyleNodeCoreModules;
+    function getNewLineKind(newLineCharacter) {
+        return newLineCharacter === "\n" ? 1 /* LineFeed */ : 0 /* CarriageReturnLineFeed */;
+    }
+    ts.getNewLineKind = getNewLineKind;
     // #endregion
 })(ts || (ts = {}));
 /*@internal*/
@@ -127140,7 +127335,7 @@ var ts;
     (function (Completions) {
         var StringCompletions;
         (function (StringCompletions) {
-            function getStringLiteralCompletions(sourceFile, position, contextToken, checker, options, host, log, preferences) {
+            function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences) {
                 if (ts.isInReferenceComment(sourceFile, position)) {
                     var entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host);
                     return entries && convertPathCompletions(entries);
@@ -127148,12 +127343,12 @@ var ts;
                 if (ts.isInString(sourceFile, position, contextToken)) {
                     if (!contextToken || !ts.isStringLiteralLike(contextToken))
                         return undefined;
-                    var entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker, options, host, preferences);
-                    return convertStringLiteralCompletions(entries, contextToken, sourceFile, checker, log, options, preferences);
+                    var entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, program.getTypeChecker(), options, host, preferences);
+                    return convertStringLiteralCompletions(entries, contextToken, sourceFile, host, program, log, options, preferences);
                 }
             }
             StringCompletions.getStringLiteralCompletions = getStringLiteralCompletions;
-            function convertStringLiteralCompletions(completion, contextToken, sourceFile, checker, log, options, preferences) {
+            function convertStringLiteralCompletions(completion, contextToken, sourceFile, host, program, log, options, preferences) {
                 if (completion === undefined) {
                     return undefined;
                 }
@@ -127163,7 +127358,7 @@ var ts;
                         return convertPathCompletions(completion.paths);
                     case 1 /* Properties */: {
                         var entries = [];
-                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, checker, 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); // Target will not be used, so arbitrary
                         return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan: optionalReplacementSpan, entries: entries };
                     }
                     case 2 /* Types */: {
@@ -127997,7 +128192,6 @@ var ts;
             }
             // If the request is a continuation of an earlier `isIncomplete` response,
             // we can continue it from the cached previous response.
-            var typeChecker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
             var incompleteCompletionsCache = preferences.allowIncompleteCompletions ? (_a = host.getIncompleteCompletionsCache) === null || _a === void 0 ? void 0 : _a.call(host) : undefined;
             if (incompleteCompletionsCache && completionKind === 3 /* TriggerForIncompleteCompletions */ && previousToken && ts.isIdentifier(previousToken)) {
@@ -128009,7 +128203,7 @@ var ts;
             else {
                 incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.clear();
             }
-            var stringCompletions = Completions.StringCompletions.getStringLiteralCompletions(sourceFile, position, previousToken, typeChecker, compilerOptions, host, log, preferences);
+            var stringCompletions = Completions.StringCompletions.getStringLiteralCompletions(sourceFile, position, previousToken, compilerOptions, host, program, log, preferences);
             if (stringCompletions) {
                 return stringCompletions;
             }
@@ -128023,7 +128217,7 @@ var ts;
             }
             switch (completionData.kind) {
                 case 0 /* Data */:
-                    var response = completionInfoFromData(sourceFile, typeChecker, compilerOptions, log, completionData, preferences);
+                    var response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences);
                     if (response === null || response === void 0 ? void 0 : response.isIncomplete) {
                         incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.set(response);
                     }
@@ -128120,7 +128314,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, typeChecker, compilerOptions, log, completionData, preferences) {
+        function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences) {
             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 */) {
@@ -128132,7 +128326,7 @@ var ts;
             var entries = [];
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, typeChecker, 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, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
                 getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries); // TODO: GH#18217
             }
             else {
@@ -128140,7 +128334,7 @@ var ts;
                     return undefined;
                 }
                 getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, typeChecker, 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, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
             }
             if (keywordFilters !== 0 /* None */) {
                 var entryNames = new ts.Set(entries.map(function (e) { return e.name; }));
@@ -128246,14 +128440,15 @@ 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, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences) {
-            var _a;
+        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind) {
+            var _a, _b;
             var insertText;
             var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken);
             var data;
             var isSnippet;
             var sourceDisplay;
             var hasAction;
+            var typeChecker = program.getTypeChecker();
             var insertQuestionDot = origin && originIsNullableMember(origin);
             var useBraces = origin && originIsSymbolMember(origin) || needsConvertPropertyAccess;
             if (origin && originIsThisType(origin)) {
@@ -128304,12 +128499,11 @@ var ts;
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
-            if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
-                return undefined;
-            }
-            if (originIsExport(origin) || originIsResolvedExport(origin)) {
-                data = originToCompletionEntryData(origin);
-                hasAction = !importCompletionNode;
+            if (preferences.includeCompletionsWithClassMemberSnippets &&
+                preferences.includeCompletionsWithInsertText &&
+                completionKind === 3 /* MemberLike */ &&
+                isClassLikeMemberCompletion(symbol, location)) {
+                (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken), insertText = _b.insertText, isSnippet = _b.isSnippet);
             }
             var kind = ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, location);
             if (kind === "JSX attribute" /* jsxAttribute */ && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
@@ -128321,7 +128515,7 @@ var ts;
                     && !(type.flags & 1048576 /* Union */ && ts.find(type.types, function (type) { return !!(type.flags & 528 /* BooleanLike */); }))) {
                     if (type.flags & 402653316 /* StringLike */ || (type.flags & 1048576 /* Union */ && ts.every(type.types, function (type) { return !!(type.flags & (402653316 /* StringLike */ | 32768 /* Undefined */)); }))) {
                         // If is string like or undefined use quotes
-                        insertText = escapeSnippetText(name) + "=" + ts.quote(sourceFile, preferences, "$1");
+                        insertText = ts.escapeSnippetText(name) + "=" + ts.quote(sourceFile, preferences, "$1");
                         isSnippet = true;
                     }
                     else {
@@ -128330,13 +128524,20 @@ var ts;
                     }
                 }
                 if (useBraces_1) {
-                    insertText = escapeSnippetText(name) + "={$1}";
+                    insertText = ts.escapeSnippetText(name) + "={$1}";
                     isSnippet = true;
                 }
                 if (isSnippet) {
                     replacementSpan = ts.createTextSpanFromNode(location, sourceFile);
                 }
             }
+            if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
+                return undefined;
+            }
+            if (originIsExport(origin) || originIsResolvedExport(origin)) {
+                data = originToCompletionEntryData(origin);
+                hasAction = !importCompletionNode;
+            }
             // TODO(drosen): Right now we just permit *all* semantic meanings when calling
             // 'getSymbolKind' which is permissible given that it is backwards compatible; but
             // really we should consider passing the meaning for the node so that we don't report
@@ -128361,8 +128562,203 @@ var ts;
                 data: data,
             };
         }
-        function escapeSnippetText(text) {
-            return text.replace(/\$/gm, "\\$");
+        function isClassLikeMemberCompletion(symbol, location) {
+            // TODO: support JS files.
+            if (ts.isInJSFile(location)) {
+                return false;
+            }
+            // Completion symbol must be for a class member.
+            var memberFlags = 106500 /* ClassMember */
+                & 900095 /* EnumMemberExcludes */;
+            /* In
+            `class C {
+                |
+            }`
+            `location` is a class-like declaration.
+            In
+            `class C {
+                m|
+            }`
+            `location` is an identifier,
+            `location.parent` is a class element declaration,
+            and `location.parent.parent` is a class-like declaration.
+            In
+            `abstract class C {
+                abstract
+                abstract m|
+            }`
+            `location` is a syntax list (with modifiers as children),
+            and `location.parent` is a class-like declaration.
+            */
+            return !!(symbol.flags & memberFlags) &&
+                (ts.isClassLike(location) ||
+                    (location.parent &&
+                        location.parent.parent &&
+                        ts.isClassElement(location.parent) &&
+                        location === location.parent.name &&
+                        ts.isClassLike(location.parent.parent)) ||
+                    (location.parent &&
+                        ts.isSyntaxList(location) &&
+                        ts.isClassLike(location.parent)));
+        }
+        function getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken) {
+            var classLikeDeclaration = ts.findAncestor(location, ts.isClassLike);
+            if (!classLikeDeclaration) {
+                return { insertText: name };
+            }
+            var isSnippet;
+            var insertText = name;
+            var checker = program.getTypeChecker();
+            var sourceFile = location.getSourceFile();
+            var printer = createSnippetPrinter({
+                removeComments: true,
+                module: options.module,
+                target: options.target,
+                omitTrailingSemicolon: true,
+                newLine: ts.getNewLineKind(ts.getNewLineCharacter(options, ts.maybeBind(host, host.getNewLine))),
+            });
+            var importAdder = ts.codefix.createImportAdder(sourceFile, program, preferences, host);
+            var body;
+            var tabstopStart = 1;
+            if (preferences.includeCompletionsWithSnippetText) {
+                isSnippet = true;
+                // We are adding a final tabstop (i.e. $0) in the body of the suggested member, if it has one.
+                // Note: this assumes we won't have more than one body in the completion nodes, which should be the case.
+                var emptyStatement1 = ts.factory.createExpressionStatement(ts.factory.createIdentifier(""));
+                ts.setSnippetElement(emptyStatement1, { kind: 0 /* TabStop */, order: 1 });
+                tabstopStart = 2;
+                body = ts.factory.createBlock([emptyStatement1], /* multiline */ true);
+            }
+            else {
+                body = ts.factory.createBlock([], /* multiline */ true);
+            }
+            var modifiers = 0 /* None */;
+            // Whether the suggested member should be abstract.
+            // e.g. in `abstract class C { abstract | }`, we should offer abstract method signatures at position `|`.
+            // Note: We are relying on checking if the context token is `abstract`,
+            // since other visibility modifiers (e.g. `protected`) should come *before* `abstract`.
+            // However, that is not true for the e.g. `override` modifier, so this check has its limitations.
+            var isAbstract = contextToken && isModifierLike(contextToken) === 126 /* AbstractKeyword */;
+            var completionNodes = [];
+            ts.codefix.addNewNodeForMemberSymbol(symbol, classLikeDeclaration, sourceFile, { program: program, host: host }, preferences, importAdder, 
+            // `addNewNodeForMemberSymbol` calls this callback function for each new member node
+            // it adds for the given member symbol.
+            // We store these member nodes in the `completionNodes` array.
+            // Note: there might be:
+            //  - No nodes if `addNewNodeForMemberSymbol` cannot figure out a node for the member;
+            //  - One node;
+            //  - More than one node if the member is overloaded (e.g. a method with overload signatures).
+            function (node) {
+                var requiredModifiers = 0 /* None */;
+                if (isAbstract) {
+                    requiredModifiers |= 128 /* Abstract */;
+                }
+                if (ts.isClassElement(node)
+                    && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === 1 /* NeedsOverride */) {
+                    requiredModifiers |= 16384 /* Override */;
+                }
+                var presentModifiers = 0 /* None */;
+                if (!completionNodes.length) {
+                    // Omit already present modifiers from the first completion node/signature.
+                    if (contextToken) {
+                        presentModifiers = getPresentModifiers(contextToken);
+                    }
+                    // Keep track of added missing required modifiers and modifiers already present.
+                    // This is needed when we have overloaded signatures,
+                    // so this callback will be called for multiple nodes/signatures,
+                    // and we need to make sure the modifiers are uniform for all nodes/signatures.
+                    modifiers = node.modifierFlagsCache | requiredModifiers | presentModifiers;
+                }
+                node = ts.factory.updateModifiers(node, modifiers & (~presentModifiers));
+                completionNodes.push(node);
+            }, body, isAbstract);
+            if (completionNodes.length) {
+                if (preferences.includeCompletionsWithSnippetText) {
+                    addSnippets(completionNodes, tabstopStart);
+                }
+                insertText = printer.printSnippetList(1 /* MultiLine */, ts.factory.createNodeArray(completionNodes), sourceFile);
+            }
+            return { insertText: insertText, isSnippet: isSnippet };
+        }
+        function getPresentModifiers(contextToken) {
+            var modifiers = 0 /* None */;
+            var contextMod;
+            /*
+            Cases supported:
+            In
+            `class C {
+                public abstract |
+            }`
+            `contextToken` is ``abstract`` (as an identifier),
+            `contextToken.parent` is property declaration,
+            `location` is class declaration ``class C { ... }``.
+            In
+            `class C {
+                protected override m|
+            }`
+                `contextToken` is ``override`` (as a keyword),
+            `contextToken.parent` is property declaration,
+            `location` is identifier ``m``,
+            `location.parent` is property declaration ``protected override m``,
+            `location.parent.parent` is class declaration ``class C { ... }``.
+            */
+            if (contextMod = isModifierLike(contextToken)) {
+                modifiers |= ts.modifierToFlag(contextMod);
+            }
+            if (ts.isPropertyDeclaration(contextToken.parent)) {
+                modifiers |= ts.modifiersToFlags(contextToken.parent.modifiers);
+            }
+            return modifiers;
+        }
+        function isModifierLike(node) {
+            if (ts.isModifier(node)) {
+                return node.kind;
+            }
+            if (ts.isIdentifier(node) && node.originalKeywordKind && ts.isModifierKind(node.originalKeywordKind)) {
+                return node.originalKeywordKind;
+            }
+            return undefined;
+        }
+        function addSnippets(nodes, orderStart) {
+            var order = orderStart;
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
+                addSnippetsWorker(node, /*parent*/ undefined);
+            }
+            function addSnippetsWorker(node, parent) {
+                if (ts.isVariableLike(node) && node.kind === 163 /* Parameter */) {
+                    // Placeholder
+                    ts.setSnippetElement(node.name, { kind: 1 /* Placeholder */, order: order });
+                    order += 1;
+                    if (node.type) {
+                        ts.setSnippetElement(node.type, { kind: 1 /* Placeholder */, order: order });
+                        order += 1;
+                    }
+                }
+                else if (ts.isTypeNode(node) && parent && ts.isFunctionLikeDeclaration(parent)) {
+                    ts.setSnippetElement(node, { kind: 1 /* Placeholder */, order: order });
+                    order += 1;
+                }
+                else if (ts.isTypeParameterDeclaration(node) && parent && ts.isFunctionLikeDeclaration(parent)) {
+                    ts.setSnippetElement(node, { kind: 1 /* Placeholder */, order: order });
+                    order += 1;
+                }
+                ts.forEachChild(node, function (child) { return addSnippetsWorker(child, node); });
+            }
+        }
+        function createSnippetPrinter(printerOptions) {
+            var printer = ts.createPrinter(printerOptions);
+            var baseWriter = ts.createTextWriter(ts.getNewLineCharacter(printerOptions));
+            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,
+            };
+            /* Snippet-escaping version of `printer.printList`. */
+            function printSnippetList(format, list, sourceFile) {
+                writer.clear();
+                printer.writeList(format, list, sourceFile, writer);
+                return writer.getText();
+            }
         }
         function originToCompletionEntryData(origin) {
             var ambientModuleName = origin.fileName ? undefined : ts.stripQuotes(origin.moduleSymbol.name);
@@ -128430,10 +128826,10 @@ var ts;
             var importSpecifierTypeOnlyText = isImportSpecifierTypeOnly ? ts.tokenToString(151 /* TypeKeyword */) + " " : "";
             var suffix = useSemicolons ? ";" : "";
             switch (importKind) {
-                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
-                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
-                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "* as " + escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
-                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "{ " + importSpecifierTypeOnlyText + escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
+                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + ts.escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
+                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + ts.escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
+                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "* as " + ts.escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
+                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "{ " + importSpecifierTypeOnlyText + ts.escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
             }
         }
         function quotePropertyName(sourceFile, preferences, name) {
@@ -128457,11 +128853,12 @@ var ts;
                 return CompletionSource.ThisProperty;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, typeChecker, 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, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
             var useSemicolons = ts.probablyUsesSemicolons(sourceFile);
+            var typeChecker = program.getTypeChecker();
             // Tracks unique names.
             // Value is set to false for global variables or completions from external module exports, because we can have multiple of those;
             // true otherwise. Based on the order we add things we will always see locals first, then globals, then module exports.
@@ -128477,7 +128874,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, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences);
+                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind);
                 if (!entry) {
                     continue;
                 }
@@ -143869,8 +144266,8 @@ var ts;
             ChangeTracker.prototype.deleteNodes = function (sourceFile, nodes, options, hasTrailingComment) {
                 if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; }
                 // When deleting multiple nodes we need to track if the end position is including multiline trailing comments.
-                for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-                    var node = nodes_1[_i];
+                for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                    var node = nodes_2[_i];
                     var pos = getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment);
                     var end = getAdjustedEndPosition(sourceFile, node, options);
                     this.deleteRange(sourceFile, { pos: pos, end: end });
@@ -144510,7 +144907,7 @@ var ts;
             /** Note: output node may be mutated input node. */
             function getNonformattedText(node, sourceFile, newLineCharacter) {
                 var writer = createWriter(newLineCharacter);
-                var newLine = newLineCharacter === "\n" ? 1 /* LineFeed */ : 0 /* CarriageReturnLineFeed */;
+                var newLine = ts.getNewLineKind(newLineCharacter);
                 ts.createPrinter({
                     newLine: newLine,
                     neverAsciiEscape: true,
@@ -152111,7 +152508,7 @@ var ts;
             for (var _i = 0, possiblyMissingSymbols_1 = possiblyMissingSymbols; _i < possiblyMissingSymbols_1.length; _i++) {
                 var symbol = possiblyMissingSymbols_1[_i];
                 if (!classMembers.has(symbol.escapedName)) {
-                    addNewNodeForMemberSymbol(symbol, classDeclaration, sourceFile, context, preferences, importAdder, addClassElement);
+                    addNewNodeForMemberSymbol(symbol, classDeclaration, sourceFile, context, preferences, importAdder, addClassElement, /* body */ undefined);
                 }
             }
         }
@@ -152124,9 +152521,11 @@ var ts;
         }
         codefix.getNoopSymbolTrackerWithResolver = getNoopSymbolTrackerWithResolver;
         /**
-         * @returns Empty string iff there we can't figure out a representation for `symbol` in `enclosingDeclaration`.
+         * `addClassElement` will not be called if we can't figure out a representation for `symbol` in `enclosingDeclaration`.
+         * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
          */
-        function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement) {
+        function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, isAmbient) {
+            if (isAmbient === void 0) { isAmbient = false; }
             var declarations = symbol.getDeclarations();
             if (!(declarations && declarations.length)) {
                 return undefined;
@@ -152139,7 +152538,7 @@ var ts;
             var modifiers = visibilityModifier ? ts.factory.createNodeArray([visibilityModifier]) : undefined;
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
             var optional = !!(symbol.flags & 16777216 /* Optional */);
-            var ambient = !!(enclosingDeclaration.flags & 8388608 /* Ambient */);
+            var ambient = !!(enclosingDeclaration.flags & 8388608 /* Ambient */) || isAmbient;
             var quotePreference = ts.getQuotePreference(sourceFile, preferences);
             switch (declaration.kind) {
                 case 165 /* PropertySignature */:
@@ -152175,14 +152574,14 @@ var ts;
                         var accessor = orderedAccessors_1[_i];
                         if (ts.isGetAccessorDeclaration(accessor)) {
                             addClassElement(ts.factory.createGetAccessorDeclaration(
-                            /*decorators*/ undefined, modifiers, name, ts.emptyArray, typeNode_1, ambient ? undefined : createStubbedMethodBody(quotePreference)));
+                            /*decorators*/ undefined, modifiers, name, ts.emptyArray, typeNode_1, ambient ? undefined : body || createStubbedMethodBody(quotePreference)));
                         }
                         else {
                             ts.Debug.assertNode(accessor, ts.isSetAccessorDeclaration, "The counterpart to a getter should be a setter");
                             var parameter = ts.getSetAccessorValueParameter(accessor);
                             var parameterName = parameter && ts.isIdentifier(parameter.name) ? ts.idText(parameter.name) : undefined;
                             addClassElement(ts.factory.createSetAccessorDeclaration(
-                            /*decorators*/ undefined, modifiers, name, createDummyParameters(1, [parameterName], [typeNode_1], 1, /*inJs*/ false), ambient ? undefined : createStubbedMethodBody(quotePreference)));
+                            /*decorators*/ undefined, modifiers, name, createDummyParameters(1, [parameterName], [typeNode_1], 1, /*inJs*/ false), ambient ? undefined : body || createStubbedMethodBody(quotePreference)));
                         }
                     }
                     break;
@@ -152203,7 +152602,7 @@ var ts;
                     if (declarations.length === 1) {
                         ts.Debug.assert(signatures.length === 1, "One declaration implies one signature");
                         var signature = signatures[0];
-                        outputMethod(quotePreference, signature, modifiers, name, ambient ? undefined : createStubbedMethodBody(quotePreference));
+                        outputMethod(quotePreference, signature, modifiers, name, ambient ? undefined : body || createStubbedMethodBody(quotePreference));
                         break;
                     }
                     for (var _a = 0, signatures_1 = signatures; _a < signatures_1.length; _a++) {
@@ -152214,11 +152613,11 @@ var ts;
                     if (!ambient) {
                         if (declarations.length > signatures.length) {
                             var signature = checker.getSignatureFromDeclaration(declarations[declarations.length - 1]);
-                            outputMethod(quotePreference, signature, modifiers, name, createStubbedMethodBody(quotePreference));
+                            outputMethod(quotePreference, signature, modifiers, name, body || createStubbedMethodBody(quotePreference));
                         }
                         else {
                             ts.Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
-                            addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference));
+                            addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body));
                         }
                     }
                     break;
@@ -152229,6 +152628,7 @@ var ts;
                     addClassElement(method);
             }
         }
+        codefix.addNewNodeForMemberSymbol = addNewNodeForMemberSymbol;
         function createSignatureDeclarationFromSignature(kind, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder) {
             var program = context.program;
             var checker = program.getTypeChecker();
@@ -152366,7 +152766,7 @@ var ts;
             }
             return parameters;
         }
-        function createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference) {
+        function createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body) {
             /** This is *a* signature with the maximal number of arguments,
              * such that if there is a "maximal" signature without rest arguments,
              * this is one of them.
@@ -152397,7 +152797,7 @@ var ts;
                 parameters.push(restParameter);
             }
             return createStubbedMethod(modifiers, name, optional, 
-            /*typeParameters*/ undefined, parameters, getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration), quotePreference);
+            /*typeParameters*/ undefined, parameters, getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration), quotePreference, body);
         }
         function getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration) {
             if (ts.length(signatures)) {
@@ -152405,10 +152805,10 @@ var ts;
                 return checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context));
             }
         }
-        function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference) {
+        function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference, body) {
             return ts.factory.createMethodDeclaration(
             /*decorators*/ undefined, modifiers, 
-            /*asteriskToken*/ undefined, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeParameters, parameters, returnType, createStubbedMethodBody(quotePreference));
+            /*asteriskToken*/ undefined, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeParameters, parameters, returnType, body || createStubbedMethodBody(quotePreference));
         }
         function createStubbedMethodBody(quotePreference) {
             return createStubbedBody(ts.Diagnostics.Method_not_implemented.message, quotePreference);
@@ -158419,8 +158819,8 @@ var ts;
         var list = createNode(346 /* SyntaxList */, nodes.pos, nodes.end, parent);
         list._children = [];
         var pos = nodes.pos;
-        for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-            var node = nodes_2[_i];
+        for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+            var node = nodes_3[_i];
             addSyntheticNodes(list._children, pos, node.pos, parent);
             list._children.push(node);
             pos = node.end;