typescript 4.6.0-dev.20211202 → 4.6.0-dev.20211206

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211206";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1037,7 +1037,11 @@ var ts;
         }
         return deduplicated;
     }
-    function insertSorted(array, insert, compare) {
+    function createSortedArray() {
+        return []; // TODO: GH#19873
+    }
+    ts.createSortedArray = createSortedArray;
+    function insertSorted(array, insert, compare, allowDuplicates) {
         if (array.length === 0) {
             array.push(insert);
             return;
@@ -1046,6 +1050,9 @@ var ts;
         if (insertIndex < 0) {
             array.splice(~insertIndex, 0, insert);
         }
+        else if (allowDuplicates) {
+            array.splice(insertIndex, 0, insert);
+        }
     }
     ts.insertSorted = insertSorted;
     function sortAndDeduplicate(array, comparer, equalityComparer) {
@@ -8411,6 +8418,7 @@ var ts;
         Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: diag(2308, ts.DiagnosticCategory.Error, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."),
         An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: diag(2309, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."),
         Type_0_recursively_references_itself_as_a_base_type: diag(2310, ts.DiagnosticCategory.Error, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."),
+        Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function: diag(2311, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function_2311", "Cannot find name '{0}'. Did you mean to write this in an async function?"),
         An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2312, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."),
         Type_parameter_0_has_a_circular_constraint: diag(2313, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."),
         Generic_type_0_requires_1_type_argument_s: diag(2314, ts.DiagnosticCategory.Error, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."),
@@ -20952,6 +20960,10 @@ var ts;
         return text.replace(/\$/gm, "\\$");
     }
     ts.escapeSnippetText = escapeSnippetText;
+    function isThisTypeParameter(type) {
+        return !!(type.flags & 262144 /* TypeParameter */ && type.isThisType);
+    }
+    ts.isThisTypeParameter = isThisTypeParameter;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -41647,7 +41659,10 @@ var ts;
             }
         }
         var failedLookupLocations = [];
-        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.AllFeatures, conditions: ["node", "require", "types"] };
+        var features = ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
+            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
+                NodeResolutionFeatures.None;
+        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: ["node", "require", "types"] };
         var resolved = primaryLookup();
         var primary = true;
         if (!resolved) {
@@ -42322,13 +42337,15 @@ var ts;
         // not currently backported to node 12 - https://github.com/nodejs/Release/issues/690
         NodeResolutionFeatures[NodeResolutionFeatures["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers";
         NodeResolutionFeatures[NodeResolutionFeatures["AllFeatures"] = 30] = "AllFeatures";
+        NodeResolutionFeatures[NodeResolutionFeatures["Node12Default"] = 14] = "Node12Default";
+        NodeResolutionFeatures[NodeResolutionFeatures["NodeNextDefault"] = 30] = "NodeNextDefault";
         NodeResolutionFeatures[NodeResolutionFeatures["EsmMode"] = 32] = "EsmMode";
     })(NodeResolutionFeatures || (NodeResolutionFeatures = {}));
     function node12ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
-        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.Imports | NodeResolutionFeatures.SelfName | NodeResolutionFeatures.Exports, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.Node12Default, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
     }
     function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
-        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.AllFeatures, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
     }
     function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         var containingDirectory = ts.getDirectoryPath(containingFile);
@@ -47034,6 +47051,7 @@ var ts;
             getIndexInfosOfType: getIndexInfosOfType,
             getSignaturesOfType: getSignaturesOfType,
             getIndexTypeOfType: function (type, kind) { return getIndexTypeOfType(type, kind === 0 /* String */ ? stringType : numberType); },
+            getIndexType: function (type) { return getIndexType(type); },
             getBaseTypes: getBaseTypes,
             getBaseTypeOfLiteralType: getBaseTypeOfLiteralType,
             getWidenedType: getWidenedType,
@@ -48291,11 +48309,12 @@ var ts;
          *
          * @param isUse If true, this will count towards --noUnusedLocals / --noUnusedParameters.
          */
-        function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals) {
+        function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggstions) {
             if (excludeGlobals === void 0) { excludeGlobals = false; }
-            return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSymbol);
+            if (getSpellingSuggstions === void 0) { getSpellingSuggstions = true; }
+            return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggstions, getSymbol);
         }
-        function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, lookup) {
+        function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, lookup) {
             var _a, _b, _c;
             var originalLocation = location; // needed for did-you-mean error reporting, which gathers candidates starting from the original location
             var result;
@@ -48612,7 +48631,7 @@ var ts;
                 }
             }
             if (!result) {
-                if (nameNotFoundMessage) {
+                if (nameNotFoundMessage && produceDiagnostics) {
                     if (!errorLocation ||
                         !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && // TODO: GH#18217
                             !checkAndReportErrorForExtendingInterface(errorLocation) &&
@@ -48622,7 +48641,7 @@ var ts;
                             !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
                             !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
                         var suggestion = void 0;
-                        if (suggestionCount < maximumSuggestionCount) {
+                        if (getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
                             suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
                             var isGlobalScopeAugmentationDeclaration = (suggestion === null || suggestion === void 0 ? void 0 : suggestion.valueDeclaration) && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration);
                             if (isGlobalScopeAugmentationDeclaration) {
@@ -48658,7 +48677,7 @@ var ts;
                 return undefined;
             }
             // Perform extra checks only if error reporting was requested
-            if (nameNotFoundMessage) {
+            if (nameNotFoundMessage && produceDiagnostics) {
                 if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
@@ -51134,7 +51153,7 @@ var ts;
                     context.approximateLength += 6;
                     return ts.factory.createKeywordTypeNode(147 /* ObjectKeyword */);
                 }
-                if (isThisTypeParameter(type)) {
+                if (ts.isThisTypeParameter(type)) {
                     if (context.flags & 4194304 /* InObjectTypeLiteral */) {
                         if (!context.encounteredError && !(context.flags & 32768 /* AllowThisInObjectLiteral */)) {
                             context.encounteredError = true;
@@ -59079,7 +59098,7 @@ var ts;
         }
         function getGlobalSymbol(name, meaning, diagnostic) {
             // Don't track references for global symbols anyway, so value if `isReference` is arbitrary
-            return resolveName(undefined, name, meaning, diagnostic, name, /*isUse*/ false);
+            return resolveName(undefined, name, meaning, diagnostic, name, /*isUse*/ false, /*excludeGlobals*/ false, /*getSpellingSuggestions*/ false);
         }
         function getGlobalType(name, arity, reportErrors) {
             var symbol = getGlobalTypeSymbol(name, reportErrors);
@@ -60658,9 +60677,6 @@ var ts;
             return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 8388608 /* IsGenericObjectType */ : 0) |
                 (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 16777216 /* IsGenericIndexType */ : 0);
         }
-        function isThisTypeParameter(type) {
-            return !!(type.flags & 262144 /* TypeParameter */ && type.isThisType);
-        }
         function getSimplifiedType(type, writing) {
             return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) :
                 type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) :
@@ -65858,7 +65874,7 @@ var ts;
         // flags for the string, number, boolean, "", 0, false, void, undefined, or null types respectively. Returns
         // no flags for all other types (including non-falsy literal types).
         function getFalsyFlags(type) {
-            return type.flags & 1048576 /* Union */ ? getFalsyFlagsOfTypes(type.types) :
+            return type.flags & 3145728 /* UnionOrIntersection */ ? getFalsyFlagsOfTypes(type.types) :
                 type.flags & 128 /* StringLiteral */ ? type.value === "" ? 128 /* StringLiteral */ : 0 :
                     type.flags & 256 /* NumberLiteral */ ? type.value === 0 ? 256 /* NumberLiteral */ : 0 :
                         type.flags & 2048 /* BigIntLiteral */ ? isZeroBigInt(type) ? 2048 /* BigIntLiteral */ : 0 :
@@ -67474,6 +67490,11 @@ var ts;
                 case "BigInt64Array":
                 case "BigUint64Array":
                     return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later;
+                case "await":
+                    if (ts.isCallExpression(node.parent)) {
+                        return ts.Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function;
+                    }
+                // falls through
                 default:
                     if (node.parent.kind === 295 /* ShorthandPropertyAssignment */) {
                         return ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
@@ -69031,7 +69052,7 @@ var ts;
             function narrowByInKeyword(type, name, assumeTrue) {
                 if (type.flags & 1048576 /* Union */
                     || type.flags & 524288 /* Object */ && declaredType !== type
-                    || isThisTypeParameter(type)
+                    || ts.isThisTypeParameter(type)
                     || type.flags & 2097152 /* Intersection */ && ts.every(type.types, function (t) { return t.symbol !== globalThisSymbol; })) {
                     return filterType(type, function (t) { return isTypePresencePossible(t, name, assumeTrue); });
                 }
@@ -71851,15 +71872,9 @@ var ts;
             }
         }
         function isValidSpreadType(type) {
-            if (type.flags & 465829888 /* Instantiable */) {
-                var constraint = getBaseConstraintOfType(type);
-                if (constraint !== undefined) {
-                    return isValidSpreadType(constraint);
-                }
-            }
-            return !!(type.flags & (1 /* Any */ | 67108864 /* NonPrimitive */ | 524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */) ||
-                getFalsyFlags(type) & 117632 /* DefinitelyFalsy */ && isValidSpreadType(removeDefinitelyFalsyTypes(type)) ||
-                type.flags & 3145728 /* UnionOrIntersection */ && ts.every(type.types, isValidSpreadType));
+            var t = removeDefinitelyFalsyTypes(mapType(type, getBaseConstraintOrType));
+            return !!(t.flags & (1 /* Any */ | 67108864 /* NonPrimitive */ | 524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */) ||
+                t.flags & 3145728 /* UnionOrIntersection */ && ts.every(t.types, isValidSpreadType));
         }
         function checkJsxSelfClosingElementDeferred(node) {
             checkJsxOpeningLikeElementOrOpeningFragment(node);
@@ -72810,7 +72825,7 @@ var ts;
             }
             var propType;
             if (!prop) {
-                var indexInfo = !ts.isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ?
+                var indexInfo = !ts.isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || ts.isThisTypeParameter(leftType)) ?
                     getApplicableIndexInfoForName(apparentType, right.escapedText) : undefined;
                 if (!(indexInfo && indexInfo.type)) {
                     var isUncheckedJS = isUncheckedJSSuggestion(node, leftType.symbol, /*excludeClasses*/ true);
@@ -72827,7 +72842,7 @@ var ts;
                         return anyType;
                     }
                     if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) {
-                        reportNonexistentProperty(right, isThisTypeParameter(leftType) ? apparentType : leftType, isUncheckedJS);
+                        reportNonexistentProperty(right, ts.isThisTypeParameter(leftType) ? apparentType : leftType, isUncheckedJS);
                     }
                     return errorType;
                 }
@@ -73120,7 +73135,7 @@ var ts;
         }
         function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) {
             ts.Debug.assert(outerName !== undefined, "outername should always be defined");
-            var result = resolveNameHelper(location, outerName, meaning, /*nameNotFoundMessage*/ undefined, outerName, /*isUse*/ false, /*excludeGlobals*/ false, function (symbols, name, meaning) {
+            var result = resolveNameHelper(location, outerName, meaning, /*nameNotFoundMessage*/ undefined, outerName, /*isUse*/ false, /*excludeGlobals*/ false, /*getSpellingSuggestions*/ true, function (symbols, name, meaning) {
                 ts.Debug.assertEqual(outerName, name, "name should equal outerName");
                 var symbol = getSymbol(symbols, name, meaning);
                 // Sometimes the symbol is found when location is a return type of a function: `typeof x` and `x` is declared in the body of the function
@@ -73366,7 +73381,7 @@ var ts;
             }
             var effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
             var accessFlags = ts.isAssignmentTarget(node) ?
-                4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) :
+                4 /* Writing */ | (isGenericObjectType(objectType) && !ts.isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) :
                 32 /* ExpressionPosition */;
             var indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
             return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
@@ -86828,18 +86843,22 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
+            // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
+            // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16 /* Scientific */;
             // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint
-            // Literals with 15 or fewer characters aren't long enough to reach past 2^53 - 1
             // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway
-            if (node.numericLiteralFlags & 16 /* Scientific */ || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            if (isFractional || isScientific) {
                 return;
             }
-            // We can't rely on the runtime to accurately store and compare extremely large numeric values
-            // Even for internal use, we use getTextOfNode: https://github.com/microsoft/TypeScript/issues/33298
-            // Thus, if the runtime claims a too-large number is lower than Number.MAX_SAFE_INTEGER,
-            // it's likely addition operations on it will fail too
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            // Here `node` is guaranteed to be a numeric literal representing an integer.
+            // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because:
+            // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer.
+            // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53,
+            //    thus the result of the predicate won't be affected.
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -90301,7 +90320,7 @@ var ts;
             //   ], C.prototype, "prop");
             //
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
+            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* Ambient */));
             var descriptor = languageVersion > 0 /* ES3 */
                 ? member.kind === 166 /* PropertyDeclaration */
                     // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it
@@ -128193,7 +128212,7 @@ var ts;
                     case 0 /* Paths */:
                         return convertPathCompletions(completion.paths);
                     case 1 /* Properties */: {
-                        var entries = [];
+                        var entries = ts.createSortedArray();
                         Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, host, program, 99 /* ESNext */, log, 4 /* String */, preferences, options); // Target will not be used, so arbitrary
                         return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan: optionalReplacementSpan, entries: entries };
                     }
@@ -128391,7 +128410,7 @@ var ts;
                 var types = ts.flatMap(candidates, function (candidate) {
                     if (!ts.signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length)
                         return;
-                    var type = checker.getParameterType(candidate, argumentInfo.argumentIndex);
+                    var type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex);
                     isNewIdentifier = isNewIdentifier || !!(type.flags & 4 /* String */);
                     return getStringLiteralTypes(type, uniques);
                 });
@@ -129075,6 +129094,29 @@ var ts;
             }
         }
         Completions.getCompletionsAtPosition = getCompletionsAtPosition;
+        // Editors will use the `sortText` and then fall back to `name` for sorting, but leave ties in response order.
+        // So, it's important that we sort those ties in the order we want them displayed if it matters. We don't
+        // strictly need to sort by name or SortText here since clients are going to do it anyway, but we have to
+        // do the work of comparing them so we can sort those ties appropriately; plus, it makes the order returned
+        // by the language service consistent with what TS Server does and what editors typically do. This also makes
+        // completions tests make more sense. We used to sort only alphabetically and only in the server layer, but
+        // this made tests really weird, since most fourslash tests don't use the server.
+        function compareCompletionEntries(entryInArray, entryToInsert) {
+            var _a, _b;
+            var result = ts.compareStringsCaseSensitiveUI(entryInArray.sortText, entryToInsert.sortText);
+            if (result === 0 /* EqualTo */) {
+                result = ts.compareStringsCaseSensitiveUI(entryInArray.name, entryToInsert.name);
+            }
+            if (result === 0 /* EqualTo */ && ((_a = entryInArray.data) === null || _a === void 0 ? void 0 : _a.moduleSpecifier) && ((_b = entryToInsert.data) === null || _b === void 0 ? void 0 : _b.moduleSpecifier)) {
+                // Sort same-named auto-imports by module specifier
+                result = ts.compareNumberOfDirectorySeparators(entryInArray.data.moduleSpecifier, entryToInsert.data.moduleSpecifier);
+            }
+            if (result === 0 /* EqualTo */) {
+                // Fall back to symbol order - if we return `EqualTo`, `insertSorted` will put later symbols first.
+                return -1 /* LessThan */;
+            }
+            return result;
+        }
         function completionEntryDataIsResolved(data) {
             return !!(data === null || data === void 0 ? void 0 : data.moduleSpecifier);
         }
@@ -129161,7 +129203,7 @@ var ts;
                     return completionInfo;
                 }
             }
-            var entries = [];
+            var entries = ts.createSortedArray();
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
                 /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
@@ -129179,13 +129221,13 @@ var ts;
                 for (var _i = 0, _a = getKeywordCompletions(keywordFilters, !insideJsDocTagTypeExpression && ts.isSourceFileJS(sourceFile)); _i < _a.length; _i++) {
                     var keywordEntry = _a[_i];
                     if (!entryNames.has(keywordEntry.name)) {
-                        entries.push(keywordEntry);
+                        ts.insertSorted(entries, keywordEntry, compareCompletionEntries, /*allowDuplicates*/ true);
                     }
                 }
             }
             for (var _b = 0, literals_1 = literals; _b < literals_1.length; _b++) {
                 var literal = literals_1[_b];
-                entries.push(createCompletionEntryForLiteral(sourceFile, preferences, literal));
+                ts.insertSorted(entries, createCompletionEntryForLiteral(sourceFile, preferences, literal), compareCompletionEntries, /*allowDuplicates*/ true);
             }
             return {
                 isGlobalCompletion: isInSnippetScope,
@@ -129261,13 +129303,13 @@ var ts;
                 var realName = ts.unescapeLeadingUnderscores(name);
                 if (!uniqueNames.has(realName) && ts.isIdentifierText(realName, target)) {
                     uniqueNames.add(realName);
-                    entries.push({
+                    ts.insertSorted(entries, {
                         name: realName,
                         kind: "warning" /* warning */,
                         kindModifiers: "",
                         sortText: SortText.JavascriptIdentifiers,
                         isFromUncheckedFile: true
-                    });
+                    }, compareCompletionEntries);
                 }
             });
         }
@@ -129691,7 +129733,7 @@ var ts;
                 /** True for locals; false for globals, module exports from other files, `this.` completions. */
                 var shouldShadowLaterSymbols = !origin && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
                 uniques.set(name, shouldShadowLaterSymbols);
-                entries.push(entry);
+                ts.insertSorted(entries, entry, compareCompletionEntries, /*allowDuplicates*/ true);
             }
             log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (ts.timestamp() - start));
             // Prevent consumers of this map from having to worry about
@@ -152168,6 +152210,7 @@ var ts;
         var errorCodes = [
             ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
             ts.Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
+            ts.Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code
         ];
         codefix.registerCodeFix({
             errorCodes: errorCodes,
@@ -159978,6 +160021,9 @@ var ts;
         TypeObject.prototype.isClass = function () {
             return !!(ts.getObjectFlags(this) & 1 /* Class */);
         };
+        TypeObject.prototype.isIndexType = function () {
+            return !!(this.flags & 4194304 /* Index */);
+        };
         Object.defineProperty(TypeObject.prototype, "typeArguments", {
             /**
              * This polyfills `referenceType.typeArguments` for API consumers
@@ -160010,6 +160056,16 @@ var ts;
         SignatureObject.prototype.getReturnType = function () {
             return this.checker.getReturnTypeOfSignature(this);
         };
+        SignatureObject.prototype.getTypeParameterAtPosition = function (pos) {
+            var type = this.checker.getParameterType(this, pos);
+            if (type.isIndexType() && ts.isThisTypeParameter(type.type)) {
+                var constraint = type.type.getConstraint();
+                if (constraint) {
+                    return this.checker.getIndexType(constraint);
+                }
+            }
+            return type;
+        };
         SignatureObject.prototype.getDocumentationComment = function () {
             return this.documentationComment || (this.documentationComment = getDocumentationComment(ts.singleElementArray(this.declaration), this.checker));
         };