tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/checker-symbols.js

@@ -2,7 +2,7 @@
 // entity names and the checker's name resolver.
 import { sideOf, signatureSideOf } from './side-state.js';
 import { isTypeAssignableToKindEx } from './checker-type-operators.js';
-import { BinaryExpression, getExpression, getInitializer, getMembers as getMemberNodes, getName, getSymbol, getText, getIsTypeOnly, getProperties, getType, getLocals, } from './ast.js';
+import { BinaryExpression, PatternAmbientModule, getExpression, getInitializer, getMembers as getMemberNodes, getName, getSymbol, getText, getIsTypeOnly, getProperties, getType, getLocals, } from './ast.js';
 import { isAmbientModule, isGlobalScopeAugmentation, nodeIsMissing } from './ast-utilities.js';
 import { CodePoints, distanceToCandidate, utf8Length } from './spelling.js';
 import { setValueDeclaration } from './binder.js';
@@ -16,12 +16,13 @@ import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { symbolToString } from './type-printer.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { getPropertyOfType } from './checker-members.js';
-import { checkComputedPropertyName, checkExpressionCached, entityNameToString } from './checker-expressions.js';
+import { checkComputedPropertyName, checkExpressionCached, entityNameToString, isConstTypeReference, } from './checker-expressions.js';
 import { getLateBindableNameOfDeclaration, getPropertyNameFromType, isTypeUsableAsPropertyName, hasLateBindableName, hasLateBindableIndexSignature, } from './checker-utilities.js';
-import { checkTypeOnlyAliasUse, markAliasDeclarationOfNameIfTypeOnly, getExportsOfModuleWorker, getTargetOfAliasDeclaration, getTypeOnlyAliasDeclaration, isTypeOnlyImportOrExportDeclaration, resolveExternalModuleNameWorker, resolveExternalModuleSymbol, resolveIndirectionAlias, } from './checker-modules.js';
+import { checkTypeOnlyAliasUse, markAliasDeclarationOfNameIfTypeOnly, getExportsOfModuleWorker, getTargetOfAliasDeclaration, getTypeOfModuleImportAttributes, getTypeOnlyAliasDeclaration, isTypeOnlyImportOrExportDeclaration, resolveExternalModuleNameWorker, resolveExternalModuleSymbol, resolveIndirectionAlias, } from './checker-modules.js';
 import { isJSAliasDeclaration } from './checker-javascript.js';
+import { isTypeIdenticalTo } from './relations.js';
 import { getFeatureMap } from './checker-features.js';
-import { addDeclaration, declarationAt, declarationCount, getDeclarations, getSymbolId, setDeclarations, Symbol, } from './symbol.js';
+import { addDeclaration, declarationAt, declarationCount, getDeclarations, getSymbolId, setDeclarations, Symbol, tryGetAmbientModuleNameFromSymbolName, } from './symbol.js';
 // ---- Name resolution
 /** The binder's name resolver with the checker's merging, alias handling and errors. */
 export class CheckerNameResolver extends NameResolver {
@@ -67,8 +68,8 @@ export class CheckerNameResolver extends NameResolver {
         const typeNode = getType(declaration);
         const inType = typeNode !== undefined && typeNode.pos <= location.pos && location.pos <= typeNode.end;
         c.error(location, inType
-            ? 965 /* Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor */
-            : 479 /* Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor */, declarationNameToString(getSourceFileOfNode(declaration), getName(declaration)), name);
+            ? 972 /* Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor */
+            : 486 /* Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor */, declarationNameToString(getSourceFileOfNode(declaration), getName(declaration)), name);
         return true;
     }
     onFailedToResolveSymbol(location, name, meaning, message) {
@@ -77,7 +78,7 @@ export class CheckerNameResolver extends NameResolver {
     onSuccessfullyResolvedSymbol(location, result, meaning, lastLocation, associatedDeclarationForContainingInitializerOrBindingName, withinDeferredContext) {
         const c = this.checker;
         const isInExternalModule = lastLocation !== undefined &&
-            lastLocation.kind === 307 /* SyntaxKind.SourceFile */ &&
+            lastLocation.kind === 308 /* SyntaxKind.SourceFile */ &&
             isExternalOrCommonJSModule(lastLocation);
         // Only names in value positions check block-scoped declaration order: a symbol may be both a
         // block-scoped variable and a namespace, as in `const foo: foo.bar`.
@@ -93,9 +94,9 @@ export class CheckerNameResolver extends NameResolver {
             (location.flags & 4194304 /* NodeFlags.JSDoc */) === 0) {
             const merged = getMergedSymbol(c, result);
             if (declarationCount(merged) !== 0 &&
-                getDeclarations(merged).every((d) => d.kind === 271 /* SyntaxKind.NamespaceExportDeclaration */ ||
-                    (d.kind === 307 /* SyntaxKind.SourceFile */ && d.globalExports !== undefined)))
-                c.addErrorOrSuggestion(c.compilerOptions.allowUmdGlobalAccess !== true, createDiagnosticForNode(location, 819 /* Diagnostics.X_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead */, [result.name]));
+                getDeclarations(merged).every((d) => d.kind === 272 /* SyntaxKind.NamespaceExportDeclaration */ ||
+                    (d.kind === 308 /* SyntaxKind.SourceFile */ && d.globalExports !== undefined)))
+                c.addErrorOrSuggestion(c.compilerOptions.allowUmdGlobalAccess !== true, createDiagnosticForNode(location, 826 /* Diagnostics.X_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead */, [result.name]));
         }
         // A parameter initializer or binding name can't reference its own parameter or the ones after it.
         const associated = associatedDeclarationForContainingInitializerOrBindingName;
@@ -107,12 +108,12 @@ export class CheckerNameResolver extends NameResolver {
             const root = getRootDeclaration(associated);
             const file = getSourceFileOfNode(associated);
             if (candidate === getSymbolOfDeclaration(c, associated))
-                c.error(location, 546 /* Diagnostics.Parameter_0_cannot_reference_itself */, declarationNameToString(file, getName(associated)));
+                c.error(location, 553 /* Diagnostics.Parameter_0_cannot_reference_itself */, declarationNameToString(file, getName(associated)));
             else if (candidate.valueDeclaration !== undefined &&
                 candidate.valueDeclaration.pos > associated.pos &&
                 getLocals(root.parent) !== undefined &&
                 getSymbolOfMeaning(c, getLocals(root.parent), candidate.name, meaning) === candidate)
-                c.error(location, 547 /* Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it */, declarationNameToString(file, getName(associated)), declarationNameToString(file, location));
+                c.error(location, 554 /* Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it */, declarationNameToString(file, getName(associated)), declarationNameToString(file, location));
         }
         if (location !== undefined && (meaning & 111551 /* SymbolFlags.Value */) !== 0)
             checkTypeOnlyAliasUse(this.checker, location, result, result.name);
@@ -125,12 +126,12 @@ export class CheckerNameResolver extends NameResolver {
             const locals = isGlobal ? getLocals(lastLocation) : undefined;
             const nonValueSymbol = locals !== undefined ? getSymbolOfMeaning(c, locals, name, ~111551 /* SymbolFlags.Value */) : undefined;
             if (nonValueSymbol !== undefined) {
-                const importDeclaration = getDeclarations(nonValueSymbol).find((d) => d.kind === 277 /* SyntaxKind.ImportSpecifier */ ||
-                    d.kind === 274 /* SyntaxKind.ImportClause */ ||
-                    d.kind === 275 /* SyntaxKind.NamespaceImport */ ||
-                    d.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */);
+                const importDeclaration = getDeclarations(nonValueSymbol).find((d) => d.kind === 278 /* SyntaxKind.ImportSpecifier */ ||
+                    d.kind === 275 /* SyntaxKind.ImportClause */ ||
+                    d.kind === 276 /* SyntaxKind.NamespaceImport */ ||
+                    d.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */);
                 if (importDeclaration !== undefined && !isTypeOnlyImportOrExportDeclaration(importDeclaration))
-                    c.error(importDeclaration, 986 /* Diagnostics.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled */, name);
+                    c.error(importDeclaration, 993 /* Diagnostics.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled */, name);
             }
         }
     }
@@ -169,10 +170,21 @@ function isES2015OrLaterConstructorName(name) {
         name === 'Set' ||
         name === 'WeakSet');
 }
+/**
+ * The name-not-found message of an identifier resolved from its own location, chosen only once the name
+ * isn't found (`onFailedToResolveSymbol`). Choosing it up front, as tsgo does, compares every resolved
+ * identifier's text with the list of names `getCannotFindNameDiagnosticForName` has messages for.
+ */
+export const cannotFindNameAtLocation = -1;
 function onFailedToResolveSymbol(c, location, name, meaning, message) {
+    if (message === cannotFindNameAtLocation)
+        message = getCannotFindNameDiagnosticForName(c, location);
     let declarationName = name;
     if (location !== undefined) {
-        if (location.parent !== undefined && location.parent.kind === 319 /* SyntaxKind.JSDocLink */)
+        // The `const` of a `const` assertion is not a name.
+        if (isConstTypeReferenceName(location))
+            return;
+        if (location.parent !== undefined && location.parent.kind === 320 /* SyntaxKind.JSDocLink */)
             return;
         if (checkAndReportErrorForMissingPrefix(c, location, name) ||
             checkAndReportErrorForExtendingInterface(c, location) ||
@@ -198,10 +210,10 @@ function onFailedToResolveSymbol(c, location, name, meaning, message) {
             isGlobalScopeAugmentation(suggestion.valueDeclaration))) {
         const suggestionName = symbolToString(c, suggestion);
         const diagnostic = createDiagnosticForNode(location, meaning === 1920 /* SymbolFlags.Namespace */
-            ? 955 /* Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 */
-            : 707 /* Diagnostics.Cannot_find_name_0_Did_you_mean_1 */, [declarationName, suggestionName]);
+            ? 962 /* Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 */
+            : 714 /* Diagnostics.Cannot_find_name_0_Did_you_mean_1 */, [declarationName, suggestionName]);
         if (suggestion.valueDeclaration !== undefined)
-            diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [suggestionName]));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 867 /* Diagnostics.X_0_is_declared_here */, [suggestionName]));
         c.addDiagnostic(diagnostic);
         return;
     }
@@ -221,13 +233,13 @@ function checkAndReportErrorForMissingPrefix(c, location, name) {
         if (classSymbol === undefined)
             break;
         if (getPropertyOfType(c, getTypeOfSymbol(c, classSymbol), name) !== undefined) {
-            c.error(location, 796 /* Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0 */, name, symbolToString(c, classSymbol));
+            c.error(location, 803 /* Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0 */, name, symbolToString(c, classSymbol));
             return true;
         }
         if (current === container && !isStatic(current)) {
             const thisType = getDeclaredTypeOfSymbol(c, classSymbol).thisType;
             if (thisType !== undefined && getPropertyOfType(c, thisType, name) !== undefined) {
-                c.error(location, 797 /* Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0 */, name);
+                c.error(location, 804 /* Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0 */, name);
                 return true;
             }
         }
@@ -236,15 +248,15 @@ function checkAndReportErrorForMissingPrefix(c, location, name) {
 }
 function isTypeReferenceIdentifier(node) {
     let current = node;
-    while (current.parent !== undefined && current.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+    while (current.parent !== undefined && current.parent.kind === 168 /* SyntaxKind.QualifiedName */)
         current = current.parent;
-    return current.parent !== undefined && current.parent.kind === 184 /* SyntaxKind.TypeReference */;
+    return current.parent !== undefined && current.parent.kind === 185 /* SyntaxKind.TypeReference */;
 }
 function checkAndReportErrorForExtendingInterface(c, location) {
     const expression = getEntityNameForExtendingInterface(location);
     if (expression !== undefined &&
         resolveEntityName(c, expression, 64 /* SymbolFlags.Interface */, true, false, undefined) !== undefined) {
-        c.error(location, 822 /* Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements */, getSourceTextOfNode(getSourceFileOfNode(expression), expression));
+        c.error(location, 829 /* Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements */, getSourceTextOfNode(getSourceFileOfNode(expression), expression));
         return true;
     }
     return false;
@@ -252,9 +264,12 @@ function checkAndReportErrorForExtendingInterface(c, location) {
 function getEntityNameForExtendingInterface(node) {
     switch (node.kind) {
         case 79 /* SyntaxKind.Identifier */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 168 /* SyntaxKind.QualifiedName */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return node.parent !== undefined ? getEntityNameForExtendingInterface(node.parent) : undefined;
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */: {
+        case 185 /* SyntaxKind.TypeReference */:
+            return node.typeName;
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */: {
             const expression = getExpression(node);
             return isEntityNameExpression(expression, false) ? expression : undefined;
         }
@@ -364,37 +379,59 @@ function checkAndReportErrorForUsingTypeAsNamespace(c, location, name, meaning)
     if (symbol === undefined)
         return false;
     const parent = location.parent;
-    if (parent !== undefined && parent.kind === 167 /* SyntaxKind.QualifiedName */) {
-        const propName = parent.right.text;
+    if (parent !== undefined && parent.kind === 168 /* SyntaxKind.QualifiedName */) {
+        const propName = getText(parent.right);
         if (getPropertyOfType(c, getDeclaredTypeOfSymbol(c, symbol), propName) !== undefined) {
-            c.error(parent, 845 /* 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 */, name, propName);
+            c.error(parent, 852 /* 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 */, name, propName);
             return true;
         }
     }
-    c.error(location, 834 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here */, name);
+    c.error(location, 841 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here */, name);
     return true;
 }
 function checkAndReportErrorForExportingPrimitiveType(c, location, name) {
     if (isPrimitiveTypeName(name) &&
         location.parent !== undefined &&
-        location.parent.kind === 282 /* SyntaxKind.ExportSpecifier */) {
-        c.error(location, 795 /* Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module */, name);
+        location.parent.kind === 283 /* SyntaxKind.ExportSpecifier */) {
+        c.error(location, 802 /* Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module */, name);
         return true;
     }
     return false;
 }
+/** Whether `node` is the `const` of a `const` assertion (`x as const`, `<const>x`). */
+function isConstTypeReferenceName(node) {
+    const parent = node.parent;
+    return (node.kind === 79 /* SyntaxKind.Identifier */ &&
+        parent !== undefined &&
+        isConstTypeReference(parent) &&
+        parent.parent !== undefined &&
+        (parent.parent.kind === 236 /* SyntaxKind.AsExpression */ || parent.parent.kind === 218 /* SyntaxKind.TypeAssertionExpression */));
+}
+/** Whether `node` is the expression of an `export =` or `export default`, or the leftmost name of it. */
+function isExportAssignmentExpressionName(node) {
+    let current = node;
+    while (current.parent !== undefined &&
+        (current.parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || current.parent.kind === 168 /* SyntaxKind.QualifiedName */))
+        current = current.parent;
+    const parent = current.parent;
+    return (parent !== undefined &&
+        parent.kind === 279 /* SyntaxKind.ExportAssignment */ &&
+        parent.expression === current);
+}
 function checkAndReportErrorForUsingNamespaceAsTypeOrValue(c, location, name, meaning) {
     if ((meaning & (111551 /* SymbolFlags.Value */ & ~788968 /* SymbolFlags.Type */)) !== 0) {
         const symbol = resolveSymbol(c, resolveName(c, location, name, 1024 /* SymbolFlags.NamespaceModule */, undefined, false, false));
         if (symbol !== undefined) {
-            c.error(location, 840 /* Diagnostics.Cannot_use_namespace_0_as_a_value */, name);
+            // checkExportAssignment decides whether `export = ns` is an error.
+            if (!isExportAssignmentExpressionName(location))
+                c.error(location, 847 /* Diagnostics.Cannot_use_namespace_0_as_a_value */, name);
             return true;
         }
     }
     else if ((meaning & (788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */)) !== 0) {
         const symbol = resolveSymbol(c, resolveName(c, location, name, 1536 /* SymbolFlags.Module */, undefined, false, false));
         if (symbol !== undefined) {
-            c.error(location, 841 /* Diagnostics.Cannot_use_namespace_0_as_a_type */, name);
+            c.error(location, 848 /* Diagnostics.Cannot_use_namespace_0_as_a_type */, name);
             return true;
         }
     }
@@ -407,29 +444,32 @@ function checkAndReportErrorForUsingTypeAsValue(c, location, name, meaning) {
         const grandparent = location.parent?.parent;
         if (grandparent !== undefined &&
             grandparent.parent !== undefined &&
-            grandparent.kind === 299 /* SyntaxKind.HeritageClause */) {
+            grandparent.kind === 300 /* SyntaxKind.HeritageClause */) {
             const heritageKind = grandparent.token;
             const containerKind = grandparent.parent.kind;
-            const isClass = containerKind === 264 /* SyntaxKind.ClassDeclaration */ || containerKind === 232 /* SyntaxKind.ClassExpression */;
-            if (containerKind === 265 /* SyntaxKind.InterfaceDeclaration */ && heritageKind === 95 /* SyntaxKind.ExtendsKeyword */)
-                c.error(location, 962 /* Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types */, name);
+            const isClass = containerKind === 265 /* SyntaxKind.ClassDeclaration */ || containerKind === 233 /* SyntaxKind.ClassExpression */;
+            if (containerKind === 266 /* SyntaxKind.InterfaceDeclaration */ && heritageKind === 95 /* SyntaxKind.ExtendsKeyword */)
+                c.error(location, 969 /* Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types */, name);
             else if (isClass && heritageKind === 95 /* SyntaxKind.ExtendsKeyword */)
-                c.error(location, 983 /* Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values */, name);
+                c.error(location, 990 /* Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values */, name);
             else if (isClass && heritageKind === 118 /* SyntaxKind.ImplementsKeyword */)
-                c.error(location, 984 /* Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types */, name);
+                c.error(location, 991 /* Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types */, name);
         }
         else
-            c.error(location, 825 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here */, name);
+            c.error(location, 832 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here */, name);
         return true;
     }
     const symbol = resolveSymbol(c, resolveName(c, location, name, 788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */, undefined, false, false));
     if (symbol !== undefined && (getSymbolFlags(c, symbol) & 111551 /* SymbolFlags.Value */) === 0) {
+        // checkExportAssignment decides whether `export = T` of a type is an error.
+        if (isExportAssignmentExpressionName(location))
+            return true;
         if (isES2015OrLaterConstructorName(name))
-            c.error(location, 735 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later */, name);
+            c.error(location, 742 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later */, name);
         else if (maybeMappedType(c, location, symbol))
-            c.error(location, 823 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0 */, name, name === 'K' ? 'P' : 'K');
+            c.error(location, 830 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0 */, name, name === 'K' ? 'P' : 'K');
         else
-            c.error(location, 825 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here */, name);
+            c.error(location, 832 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here */, name);
         return true;
     }
     return false;
@@ -437,9 +477,9 @@ function checkAndReportErrorForUsingTypeAsValue(c, location, name, meaning) {
 function maybeMappedType(c, node, symbol) {
     let container = node.parent;
     while (container !== undefined &&
-        (container.kind === 168 /* SyntaxKind.ComputedPropertyName */ || container.kind === 172 /* SyntaxKind.PropertySignature */))
+        (container.kind === 169 /* SyntaxKind.ComputedPropertyName */ || container.kind === 173 /* SyntaxKind.PropertySignature */))
         container = container.parent;
-    if (container === undefined || container.kind !== 188 /* SyntaxKind.TypeLiteral */)
+    if (container === undefined || container.kind !== 189 /* SyntaxKind.TypeLiteral */)
         return false;
     const members = getMemberNodes(container);
     if (members === undefined || members.nodes.length !== 1)
@@ -457,7 +497,7 @@ function checkAndReportErrorForUsingValueAsType(c, location, name, meaning) {
         return false;
     const symbol = resolveSymbol(c, resolveName(c, location, name, ~788968 /* SymbolFlags.Type */ & 111551 /* SymbolFlags.Value */, undefined, false, false));
     if (symbol !== undefined && (symbol.flags & 1920 /* SymbolFlags.Namespace */) === 0) {
-        c.error(location, 881 /* Diagnostics.X_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0 */, name);
+        c.error(location, 888 /* Diagnostics.X_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0 */, name);
         return true;
     }
     return false;
@@ -470,7 +510,7 @@ function mergeFileGlobals(c, file) {
             const fileGlobalThis = locals.get('globalThis');
             if (fileGlobalThis !== undefined)
                 for (const d of getDeclarations(fileGlobalThis))
-                    c.addDiagnostic(createDiagnosticForNode(d, 568 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, [
+                    c.addDiagnostic(createDiagnosticForNode(d, 575 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, [
                         'globalThis',
                     ]));
             for (const symbol of locals.values()) {
@@ -575,6 +615,7 @@ export class MergedGlobals {
     ambientModuleSymbols;
     patternAmbientModules;
     patternAmbientModuleAugmentations;
+    patternAmbientModuleAugmentationTargets;
     /** Whether the global `undefined` is the checker's own (no declaration of `undefined` merged). */
     ownUndefined;
     /** Ids of the symbols merged into each shared symbol. */
@@ -594,6 +635,7 @@ export class MergedGlobals {
         this.ambientModuleSymbols = c.ambientModuleSymbols.slice();
         this.patternAmbientModules = c.patternAmbientModules.slice();
         this.patternAmbientModuleAugmentations = new Map(c.patternAmbientModuleAugmentations);
+        this.patternAmbientModuleAugmentationTargets = new Map(c.patternAmbientModuleAugmentationTargets);
         for (const [id, target] of this.mergedSymbols) {
             let ids = this.sources.get(target);
             if (ids === undefined) {
@@ -711,6 +753,8 @@ export function initializeGlobals(c) {
             c.patternAmbientModules.push(pattern);
         for (const [name, symbol] of merged.patternAmbientModuleAugmentations)
             c.patternAmbientModuleAugmentations.set(name, symbol);
+        for (const [name, symbol] of merged.patternAmbientModuleAugmentationTargets)
+            c.patternAmbientModuleAugmentationTargets.set(name, symbol);
         addMergeDiagnostics(c, merged, 0);
         if (merged.ownUndefined)
             setGlobal(c, 'undefined', c.undefinedSymbol);
@@ -746,7 +790,7 @@ export function initializeGlobals(c) {
     if (target !== undefined) {
         for (const declaration of getDeclarations(target))
             if (!isTypeDeclaration(declaration))
-                c.addDiagnostic(createDiagnosticForNode(declaration, 568 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, ['undefined']));
+                c.addDiagnostic(createDiagnosticForNode(declaration, 575 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, ['undefined']));
     }
     else
         setGlobal(c, 'undefined', c.undefinedSymbol);
@@ -759,27 +803,28 @@ export function mergeAmbientModulesAndAugmentations(c) {
     }
     for (const symbol of c.ambientModuleSymbols)
         mergeGlobalSymbol(c, symbol);
+    mergePatternAmbientModules(c);
     for (const file of c.files)
         for (const augmentation of file.moduleAugmentations)
             if (augmentation.parent !== undefined && !isGlobalScopeAugmentation(augmentation.parent))
                 mergeModuleAugmentation(c, augmentation);
 }
 export function isAmbientModuleSymbolName(name) {
-    return name.length >= 2 && name.charCodeAt(0) === 0x22 && name.charCodeAt(name.length - 1) === 0x22;
+    return tryGetAmbientModuleNameFromSymbolName(name) !== undefined;
 }
 function isTypeDeclaration(node) {
     switch (node.kind) {
-        case 169 /* SyntaxKind.TypeParameter */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 170 /* SyntaxKind.TypeParameter */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             return true;
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return getIsTypeOnly(node);
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return getIsTypeOnly(node);
     }
     return false;
@@ -788,6 +833,43 @@ function mergeGlobalSymbol(c, symbol) {
     const globalSymbol = c.globals.get(symbol.name);
     setGlobal(c, symbol.name, globalSymbol !== undefined ? mergeSymbol(c, globalSymbol, symbol, false) : getMergedSymbol(c, symbol));
 }
+/** Merges the pattern ambient modules with the same pattern and identical import attributes types. */
+function mergePatternAmbientModules(c) {
+    const modules = c.patternAmbientModules;
+    if (modules.length === 0)
+        return;
+    const groupsByPattern = new Map();
+    const grouped = [];
+    for (const module of modules) {
+        const attributesType = getTypeOfModuleImportAttributes(c, module.symbol);
+        let groups = groupsByPattern.get(module.text);
+        let groupIndex = -1;
+        if (groups !== undefined)
+            for (const index of groups)
+                if (isTypeIdenticalTo(c, attributesType, getTypeOfModuleImportAttributes(c, grouped[index].symbol))) {
+                    groupIndex = index;
+                    break;
+                }
+        if (groupIndex === -1) {
+            if (groups === undefined) {
+                groups = [];
+                groupsByPattern.set(module.text, groups);
+            }
+            groups.push(grouped.length);
+            grouped.push(new PatternAmbientModule(module.text, module.starIndex, module.symbol));
+        }
+        else {
+            const group = grouped[groupIndex];
+            grouped[groupIndex] = new PatternAmbientModule(group.text, group.starIndex, mergeSymbol(c, group.symbol, module.symbol, false));
+        }
+    }
+    for (const module of modules)
+        if (c.globals.has(module.symbol.name))
+            setGlobal(c, module.symbol.name, getMergedSymbol(c, module.symbol));
+    modules.length = 0;
+    for (const module of grouped)
+        modules.push(module);
+}
 function mergeModuleAugmentation(c, moduleName) {
     const moduleNode = moduleName.parent;
     const augmentationSymbol = moduleNode.symbol;
@@ -800,17 +882,20 @@ function mergeModuleAugmentation(c, moduleName) {
         return;
     }
     const moduleNotFoundError = (moduleNode.parent.flags & 8388608 /* NodeFlags.Ambient */) === 0
-        ? 798 /* Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found */
+        ? 805 /* Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found */
         : undefined;
-    let mainModule = resolveExternalModuleNameWorker(c, moduleName, moduleName, moduleNotFoundError, false, true);
+    // Module augmentations can't have import attributes.
+    let mainModule = resolveExternalModuleNameWorker(c, moduleName, moduleName, moduleNotFoundError, false, true, undefined);
     if (mainModule === undefined)
         return;
     mainModule = resolveExternalModuleSymbol(c, mainModule, false);
     if ((mainModule.flags & 1920 /* SymbolFlags.Namespace */) !== 0) {
         for (const pattern of c.patternAmbientModules)
-            if (pattern.symbol === mainModule) {
+            if (getMergedSymbol(c, pattern.symbol) === mainModule) {
+                // Merging the pattern into the augmentation keeps the pattern's own exports unchanged.
                 const merged = mergeSymbol(c, augmentationSymbol, mainModule, true);
                 c.patternAmbientModuleAugmentations.set(getText(moduleName), merged);
+                c.patternAmbientModuleAugmentationTargets.set(getText(moduleName), mainModule);
                 return;
             }
         // Exports the module gets through `export *` live on the re-exported symbols; merge into those.
@@ -830,7 +915,7 @@ function mergeModuleAugmentation(c, moduleName) {
         mergeSymbol(c, mainModule, augmentationSymbol, false);
     }
     else
-        c.error(moduleName, 805 /* Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity */, getText(moduleName));
+        c.error(moduleName, 812 /* Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity */, getText(moduleName));
 }
 export function mergeSymbolTable(c, target, source, unidirectional, mergedParent) {
     for (const [id, sourceSymbol] of source) {
@@ -896,7 +981,7 @@ export function mergeSymbol(c, target, source, unidirectional) {
     else if ((target.flags & 1024 /* SymbolFlags.NamespaceModule */) !== 0) {
         // `var globalThis` already reports a conflict with the built-in.
         if (target !== c.globalThisSymbol)
-            c.error(getNameOfDeclaration(source.declaration), 783 /* Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity */, symbolToString(c, target));
+            c.error(getNameOfDeclaration(source.declaration), 790 /* Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity */, symbolToString(c, target));
     }
     else
         reportMergeSymbolError(c, target, source);
@@ -906,10 +991,10 @@ function reportMergeSymbolError(c, target, source) {
     const isEitherEnum = ((target.flags | source.flags) & 384 /* SymbolFlags.Enum */) !== 0;
     const isEitherBlockScoped = ((target.flags | source.flags) & 2 /* SymbolFlags.BlockScopedVariable */) !== 0;
     const message = isEitherEnum
-        ? 721 /* Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations */
+        ? 728 /* Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations */
         : isEitherBlockScoped
-            ? 619 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */
-            : 478 /* Diagnostics.Duplicate_identifier_0 */;
+            ? 626 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */
+            : 485 /* Diagnostics.Duplicate_identifier_0 */;
     const name = symbolToString(c, source);
     if (!isPlainJSFile(source))
         addDuplicateDeclarationErrors(c, source, message, name, target);
@@ -933,8 +1018,8 @@ export function addDuplicateDeclarationError(c, node, message, name, relatedNode
         const adjusted = getNameOfDeclaration(relatedNode) ?? relatedNode;
         if (adjusted === errorNode)
             continue;
-        const leading = createDiagnosticForNode(adjusted, 1356 /* Diagnostics.X_0_was_also_declared_here */, [name]);
-        const followOn = createDiagnosticForNode(adjusted, 1357 /* Diagnostics.X_and_here */, []);
+        const leading = createDiagnosticForNode(adjusted, 1367 /* Diagnostics.X_0_was_also_declared_here */, [name]);
+        const followOn = createDiagnosticForNode(adjusted, 1368 /* Diagnostics.X_and_here */, []);
         const related = error.relatedInformation;
         if (related.length >= 5 || hasMatchingDiagnostic(related, leading, followOn))
             continue;
@@ -948,12 +1033,7 @@ function hasMatchingDiagnostic(diagnostics, a, b) {
     return false;
 }
 function lookupOrIssueError(c, location, message, args) {
-    const diagnostic = createDiagnosticForNode(location, message, args);
-    const existing = c.diagnostics.lookup(diagnostic);
-    if (existing !== undefined)
-        return existing;
-    c.addDiagnostic(diagnostic);
-    return diagnostic;
+    return c.addDiagnostic(createDiagnosticForNode(location, message, args));
 }
 export function getExcludedSymbolFlags(flags) {
     let result = 0;
@@ -1098,10 +1178,10 @@ export function getGlobalSymbol(c, name, meaning, diagnostic) {
 function getGlobalTypeDeclaration(symbol) {
     for (const d of getDeclarations(symbol)) {
         switch (d.kind) {
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 267 /* SyntaxKind.EnumDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
                 return d;
         }
     }
@@ -1109,17 +1189,17 @@ function getGlobalTypeDeclaration(symbol) {
 }
 /** The global class or interface `name` with `arity` type parameters, or the empty (generic) object type. */
 export function getGlobalType(c, name, arity, reportErrors) {
-    const symbol = getGlobalSymbol(c, name, 788968 /* SymbolFlags.Type */, reportErrors ? 496 /* Diagnostics.Cannot_find_global_type_0 */ : undefined);
+    const symbol = getGlobalSymbol(c, name, 788968 /* SymbolFlags.Type */, reportErrors ? 503 /* Diagnostics.Cannot_find_global_type_0 */ : undefined);
     if (symbol !== undefined) {
         if ((symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) !== 0) {
             const type = getDeclaredTypeOfSymbol(c, symbol);
             if (type.typeParameterCount() === arity)
                 return type;
             if (reportErrors)
-                c.error(getGlobalTypeDeclaration(symbol), 495 /* Diagnostics.Global_type_0_must_have_1_type_parameter_s */, symbol.name, String(arity));
+                c.error(getGlobalTypeDeclaration(symbol), 502 /* Diagnostics.Global_type_0_must_have_1_type_parameter_s */, symbol.name, String(arity));
         }
         else if (reportErrors)
-            c.error(getGlobalTypeDeclaration(symbol), 494 /* Diagnostics.Global_type_0_must_be_a_class_or_interface_type */, symbol.name);
+            c.error(getGlobalTypeDeclaration(symbol), 501 /* Diagnostics.Global_type_0_must_be_a_class_or_interface_type */, symbol.name);
     }
     return arity !== 0 ? c.emptyGenericType : c.emptyObjectType;
 }
@@ -1144,13 +1224,13 @@ export function getGlobalTypeAliasSymbol(c, name, arity, reportErrors) {
     const cached = c.globalSymbolCache.get(key);
     if (cached !== undefined)
         return cached === null ? undefined : cached;
-    let symbol = getGlobalSymbol(c, name, 524288 /* SymbolFlags.TypeAlias */, reportErrors ? 496 /* Diagnostics.Cannot_find_global_type_0 */ : undefined);
+    let symbol = getGlobalSymbol(c, name, 524288 /* SymbolFlags.TypeAlias */, reportErrors ? 503 /* Diagnostics.Cannot_find_global_type_0 */ : undefined);
     if (symbol !== undefined) {
         getDeclaredTypeOfSymbol(c, symbol);
         const typeParameters = c.symbolLinks(symbol).typeParameters;
         if ((typeParameters === undefined ? 0 : typeParameters.length) !== arity) {
             if (reportErrors) {
-                c.error(getDeclarationOfKind(symbol, 266 /* SyntaxKind.TypeAliasDeclaration */), 495 /* Diagnostics.Global_type_0_must_have_1_type_parameter_s */, symbol.name, String(arity));
+                c.error(getDeclarationOfKind(symbol, 267 /* SyntaxKind.TypeAliasDeclaration */), 502 /* Diagnostics.Global_type_0_must_have_1_type_parameter_s */, symbol.name, String(arity));
             }
             symbol = undefined;
         }
@@ -1163,7 +1243,7 @@ export function getGlobalValueSymbol(c, name, reportErrors) {
     const cached = c.globalSymbolCache.get(key);
     if (cached !== undefined)
         return cached === null ? undefined : cached;
-    const symbol = getGlobalSymbol(c, name, 111551 /* SymbolFlags.Value */, reportErrors ? 634 /* Diagnostics.Cannot_find_global_value_0 */ : undefined);
+    const symbol = getGlobalSymbol(c, name, 111551 /* SymbolFlags.Value */, reportErrors ? 641 /* Diagnostics.Cannot_find_global_value_0 */ : undefined);
     c.globalSymbolCache.set(key, symbol === undefined ? null : symbol);
     return symbol;
 }
@@ -1197,22 +1277,22 @@ export function getDeclarationOfAliasSymbol(symbol) {
 }
 export function isAliasSymbolDeclaration(node) {
     switch (node.kind) {
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
-        case 275 /* SyntaxKind.NamespaceImport */:
-        case 281 /* SyntaxKind.NamespaceExport */:
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 282 /* SyntaxKind.NamespaceExport */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return true;
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return getName(node) !== undefined;
-        case 278 /* SyntaxKind.ExportAssignment */: {
+        case 279 /* SyntaxKind.ExportAssignment */: {
             const e = getExpression(node);
             return e !== undefined && isEntityNameExpressionNode(e);
         }
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return isJSAliasDeclaration(node);
     }
     return false;
@@ -1220,7 +1300,7 @@ export function isAliasSymbolDeclaration(node) {
 function isEntityNameExpressionNode(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return true;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const e = getExpression(node);
         const name = getName(node);
         return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpressionNode(e);
@@ -1249,7 +1329,7 @@ export function resolveAlias(c, symbol) {
     target = resolved ?? c.unknownSymbol;
     links.aliasTarget = target;
     if (!popTypeResolution(c)) {
-        c.error(node, 481 /* Diagnostics.Circular_definition_of_import_alias_0 */, symbolToString(c, symbol));
+        c.error(node, 488 /* Diagnostics.Circular_definition_of_import_alias_0 */, symbolToString(c, symbol));
         links.aliasTarget = c.unknownSymbol;
     }
     return links.aliasTarget;
@@ -1361,12 +1441,12 @@ function getResolvedMembersOrExports(c, symbol, isStatic) {
 }
 function getMembersOfDeclaration(decl) {
     switch (decl.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 188 /* SyntaxKind.TypeLiteral */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 189 /* SyntaxKind.TypeLiteral */:
             return getMemberNodes(decl)?.nodes;
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
             return getProperties(decl).nodes;
     }
     return undefined;
@@ -1389,7 +1469,7 @@ function lateBindMember(c, parent, early, late, decl) {
     // A recursive request falls back to the early-bound symbol.
     c.resolvedSymbols.set(decl.id, getSymbol(decl));
     const declName = getLateBindableNameOfDeclaration(decl);
-    const type = declName.kind === 213 /* SyntaxKind.ElementAccessExpression */
+    const type = declName.kind === 214 /* SyntaxKind.ElementAccessExpression */
         ? checkExpressionCached(c, declName.argumentExpression)
         : checkComputedPropertyName(c, declName);
     if (isTypeUsableAsPropertyName(type)) {
@@ -1397,7 +1477,7 @@ function lateBindMember(c, parent, early, late, decl) {
         const symbolFlags = getSymbol(decl).flags;
         let lateSymbol = late.get(memberName);
         if (lateSymbol === undefined) {
-            lateSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, memberName, 4096 /* CheckFlags.Late */);
+            lateSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, memberName, 32768 /* CheckFlags.Late */);
             late.set(memberName, lateSymbol);
         }
         const earlySymbol = early.get(memberName);
@@ -1407,9 +1487,9 @@ function lateBindMember(c, parent, early, late, decl) {
                 : getDeclarations(lateSymbol);
             const name = (type.flags & 16384) !== 0 ? declarationNameToString(getSourceFileOfNode(declName), declName) : memberName;
             for (const d of declarations)
-                c.error(getNameOfDeclaration(d) ?? d, 478 /* Diagnostics.Duplicate_identifier_0 */, name);
-            c.error(declName, 478 /* Diagnostics.Duplicate_identifier_0 */, name);
-            lateSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, memberName, 4096 /* CheckFlags.Late */);
+                c.error(getNameOfDeclaration(d) ?? d, 485 /* Diagnostics.Duplicate_identifier_0 */, name);
+            c.error(declName, 485 /* Diagnostics.Duplicate_identifier_0 */, name);
+            lateSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, memberName, 32768 /* CheckFlags.Late */);
         }
         c.symbolNameTypes.set(getSymbolId(lateSymbol), type);
         addDeclarationToLateBoundSymbol(c, lateSymbol, decl, symbolFlags);
@@ -1425,10 +1505,10 @@ function lateBindIndexSignature(c, early, late, decl) {
     if (indexSymbol === undefined) {
         const earlyIndex = early.get("\uFFFEindex" /* InternalSymbolName.Index */);
         if (earlyIndex === undefined)
-            indexSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, "\uFFFEindex" /* InternalSymbolName.Index */, 4096 /* CheckFlags.Late */);
+            indexSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, "\uFFFEindex" /* InternalSymbolName.Index */, 32768 /* CheckFlags.Late */);
         else {
             indexSymbol = cloneSymbol(c, earlyIndex);
-            indexSymbol.checkFlags |= 4096 /* CheckFlags.Late */;
+            indexSymbol.checkFlags |= 32768 /* CheckFlags.Late */;
         }
         late.set("\uFFFEindex" /* InternalSymbolName.Index */, indexSymbol);
     }
@@ -1486,6 +1566,39 @@ export function getNamedMembers(c, members, container) {
     sortSymbols(c, rest);
     return contained.length === 0 ? rest : contained.concat(rest);
 }
+/**
+ * `getNamedMembers(c, table, container)` for a table that holds `members` in this order under their names, as
+ * positions in `members`; undefined where a member is an alias (`symbolIsValue` then resolves it) or a name repeats.
+ */
+export function getNamedMemberPositions(c, members, container) {
+    const isClassOrInterface = container !== undefined && (container.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) !== 0;
+    const names = new Set();
+    const contained = [];
+    const rest = [];
+    for (let i = 0; i < members.length; i++) {
+        const symbol = members[i];
+        if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 || names.has(symbol.name))
+            return undefined;
+        names.add(symbol.name);
+        if (isReservedMemberName(symbol.name) || !symbolIsValue(c, symbol))
+            continue;
+        if (isClassOrInterface && isDeclarationContainedBy(symbol, container))
+            contained.push(i);
+        else
+            rest.push(i);
+    }
+    sortPositions(c, members, contained);
+    sortPositions(c, members, rest);
+    return contained.length === 0 ? rest : contained.concat(rest);
+}
+/** `sortSymbols` for positions in `members`. */
+function sortPositions(c, members, positions) {
+    for (let i = 1; i < positions.length; i++)
+        if (compareSymbols(c, members[positions[i - 1]], members[positions[i]]) > 0) {
+            positions.sort((a, b) => compareSymbols(c, members[a], members[b]));
+            return;
+        }
+}
 /** Sorts symbols by declaration order; members are usually in that order already. */
 function sortSymbols(c, symbols) {
     for (let i = 1; i < symbols.length; i++)
@@ -1498,9 +1611,9 @@ function sortSymbols(c, symbols) {
 export function getFirstIdentifier(node) {
     let current = node;
     for (;;) {
-        if (current.kind === 167 /* SyntaxKind.QualifiedName */)
+        if (current.kind === 168 /* SyntaxKind.QualifiedName */)
             current = current.left;
-        else if (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        else if (current.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
             current = getExpression(current);
         else
             return current;
@@ -1514,8 +1627,10 @@ export function resolveEntityName(c, name, meaning, ignoreErrors, dontResolveAli
         const message = ignoreErrors
             ? undefined
             : meaning === 1920 /* SymbolFlags.Namespace */ || (name.flags & 16 /* NodeFlags.Synthesized */) !== 0
-                ? 663 /* Diagnostics.Cannot_find_namespace_0 */
-                : getCannotFindNameDiagnosticForName(c, getFirstIdentifier(name));
+                ? 670 /* Diagnostics.Cannot_find_namespace_0 */
+                : location === undefined
+                    ? cannotFindNameAtLocation
+                    : getCannotFindNameDiagnosticForName(c, getFirstIdentifier(name));
         const resolveLocation = location ?? name;
         const text = getText(name);
         if (meaning === 1920 /* SymbolFlags.Namespace */) {
@@ -1536,20 +1651,20 @@ export function resolveEntityName(c, name, meaning, ignoreErrors, dontResolveAli
             symbol = found !== undefined ? getMergedSymbol(c, found) : undefined;
         }
     }
-    else if (name.kind === 167 /* SyntaxKind.QualifiedName */) {
+    else if (name.kind === 168 /* SyntaxKind.QualifiedName */) {
         const qualified = name;
         symbol = resolveQualifiedName(c, name, qualified.left, qualified.right, meaning, ignoreErrors, location);
     }
-    else if (name.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    else if (name.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         symbol = resolveQualifiedName(c, name, getExpression(name), getName(name), meaning, ignoreErrors, location);
     }
     else
         return undefined;
     if (symbol !== undefined && symbol !== c.unknownSymbol) {
         if ((name.flags & 16 /* NodeFlags.Synthesized */) === 0 &&
-            name.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ &&
+            name.kind !== 213 /* SyntaxKind.PropertyAccessExpression */ &&
             ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 ||
-                (name.parent !== undefined && name.parent.kind === 278 /* SyntaxKind.ExportAssignment */)))
+                (name.parent !== undefined && name.parent.kind === 279 /* SyntaxKind.ExportAssignment */)))
             markAliasDeclarationOfNameIfTypeOnly(c, name);
         // Resolve along the alias chain to the symbol with the meaning.
         while ((symbol.flags & meaning) === 0 && !dontResolveAlias && (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
@@ -1576,13 +1691,13 @@ function resolveQualifiedName(c, name, left, right, meaning, ignoreErrors, locat
     const declarationName = declarationNameToString(getSourceFileOfNode(right), right);
     const suggestion = getSpellingSuggestionForName(c, text, Array.from(getExportsOfModule(c, namespace).values()), 2623475 /* SymbolFlags.ModuleMember */);
     if (suggestion !== undefined) {
-        c.error(right, 856 /* Diagnostics.X_0_has_no_exported_member_named_1_Did_you_mean_2 */, namespaceName, declarationName, symbolToString(c, suggestion));
+        c.error(right, 863 /* Diagnostics.X_0_has_no_exported_member_named_1_Did_you_mean_2 */, namespaceName, declarationName, symbolToString(c, suggestion));
         return undefined;
     }
     let containingQualifiedName;
-    if (name.kind === 167 /* SyntaxKind.QualifiedName */) {
+    if (name.kind === 168 /* SyntaxKind.QualifiedName */) {
         containingQualifiedName = name;
-        while (containingQualifiedName.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        while (containingQualifiedName.parent.kind === 168 /* SyntaxKind.QualifiedName */)
             containingQualifiedName = containingQualifiedName.parent;
     }
     if (
@@ -1590,22 +1705,22 @@ function resolveQualifiedName(c, name, left, right, meaning, ignoreErrors, locat
     c.hasGlobalObjectType &&
         (meaning & 788968 /* SymbolFlags.Type */) !== 0 &&
         containingQualifiedName !== undefined &&
-        containingQualifiedName.parent.kind !== 222 /* SyntaxKind.TypeOfExpression */ &&
+        containingQualifiedName.parent.kind !== 223 /* SyntaxKind.TypeOfExpression */ &&
         tryGetQualifiedNameAsValue(c, containingQualifiedName) !== undefined) {
-        c.error(containingQualifiedName, 881 /* Diagnostics.X_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0 */, entityNameToString(containingQualifiedName));
+        c.error(containingQualifiedName, 888 /* Diagnostics.X_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0 */, entityNameToString(containingQualifiedName));
         return undefined;
     }
     if ((meaning & 1920 /* SymbolFlags.Namespace */) !== 0 &&
         name.parent !== undefined &&
-        name.parent.kind === 167 /* SyntaxKind.QualifiedName */) {
+        name.parent.kind === 168 /* SyntaxKind.QualifiedName */) {
         const exportedType = getSymbolOfMeaning(c, getExportsOfSymbol(c, namespace), text, 788968 /* SymbolFlags.Type */);
         if (exportedType !== undefined) {
             const qualified = name.parent;
-            c.error(qualified.right, 845 /* 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(c, getMergedSymbol(c, exportedType)), qualified.right.text);
+            c.error(qualified.right, 852 /* 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(c, getMergedSymbol(c, exportedType)), getText(qualified.right));
             return undefined;
         }
     }
-    c.error(right, 826 /* Diagnostics.Namespace_0_has_no_exported_member_1 */, namespaceName, declarationName);
+    c.error(right, 833 /* Diagnostics.Namespace_0_has_no_exported_member_1 */, namespaceName, declarationName);
     return undefined;
 }
 /** The value a qualified name denotes as a property access, if any. */
@@ -1615,8 +1730,8 @@ function tryGetQualifiedNameAsValue(c, node) {
     if (symbol === undefined)
         return undefined;
     let current = id;
-    while (current.parent.kind === 167 /* SyntaxKind.QualifiedName */) {
-        symbol = getPropertyOfType(c, getTypeOfSymbol(c, symbol), current.parent.right.text);
+    while (current.parent.kind === 168 /* SyntaxKind.QualifiedName */) {
+        symbol = getPropertyOfType(c, getTypeOfSymbol(c, symbol), getText(current.parent.right));
         if (symbol === undefined)
             return undefined;
         current = current.parent;
@@ -1637,31 +1752,31 @@ export function getCannotFindNameDiagnosticForName(c, node) {
     switch (getText(node)) {
         case 'document':
         case 'console':
-            return 734 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom */;
+            return 741 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom */;
         case '$':
             return wildcard
-                ? 731 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery */
-                : 740 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig */;
+                ? 738 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery */
+                : 747 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig */;
         case 'beforeEach':
         case 'describe':
         case 'suite':
         case 'it':
         case 'test':
             return wildcard
-                ? 732 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha */
-                : 741 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig */;
+                ? 739 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha */
+                : 748 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig */;
         case 'process':
         case 'require':
         case 'Buffer':
         case 'module':
         case 'NodeJS':
             return wildcard
-                ? 730 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode */
-                : 739 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig */;
+                ? 737 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode */
+                : 746 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig */;
         case 'Bun':
             return wildcard
-                ? 987 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun */
-                : 988 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun_and_then_add_bun_to_the_types_field_in_your_tsconfig */;
+                ? 994 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun */
+                : 995 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_Bun_Try_npm_i_save_dev_types_Slashbun_and_then_add_bun_to_the_types_field_in_your_tsconfig */;
         // tsgo lists `ast.Symbol` here rather than `Symbol`.
         case 'Map':
         case 'Set':
@@ -1680,15 +1795,15 @@ export function getCannotFindNameDiagnosticForName(c, node) {
         case 'Reflect':
         case 'BigInt64Array':
         case 'BigUint64Array':
-            return 733 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later */;
+            return 740 /* 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 (node.parent !== undefined && node.parent.kind === 214 /* SyntaxKind.CallExpression */)
-                return 489 /* Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function */;
+            if (node.parent !== undefined && node.parent.kind === 215 /* SyntaxKind.CallExpression */)
+                return 496 /* Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function */;
             break;
     }
-    if (node.parent !== undefined && node.parent.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */)
-        return 1828 /* Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer */;
-    return 482 /* Diagnostics.Cannot_find_name_0 */;
+    if (node.parent !== undefined && node.parent.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */)
+        return 1848 /* Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer */;
+    return 489 /* Diagnostics.Cannot_find_name_0 */;
 }
 /**
  * Pushes a resolution of `propertyName` on `target`. When the same resolution is already on the
@@ -1769,16 +1884,16 @@ export function reportCircularityError(c, symbol) {
     const declaration = symbol.valueDeclaration;
     if (declaration !== undefined) {
         if (getType(declaration) !== undefined) {
-            c.error(declaration, 662 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
+            c.error(declaration, 669 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation */, symbolToString(c, symbol));
             return c.errorType;
         }
-        if (c.noImplicitAny && (declaration.kind !== 170 /* SyntaxKind.Parameter */ || getInitializer(declaration) !== undefined))
-            c.error(declaration, 1693 /* Diagnostics.X_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer */, symbolToString(c, symbol));
+        if (c.noImplicitAny && (declaration.kind !== 171 /* SyntaxKind.Parameter */ || getInitializer(declaration) !== undefined))
+            c.error(declaration, 1712 /* Diagnostics.X_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer */, symbolToString(c, symbol));
     }
     else if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
         const node = getDeclarationOfAliasSymbol(symbol);
         if (node !== undefined)
-            c.error(node, 481 /* Diagnostics.Circular_definition_of_import_alias_0 */, symbolToString(c, symbol));
+            c.error(node, 488 /* Diagnostics.Circular_definition_of_import_alias_0 */, symbolToString(c, symbol));
     }
     // Circularities could also result from parameters in function expressions that end up having themselves as
     // contextual types. Those are reported elsewhere.