tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,1782 @@
+// Symbols: merging globals and augmentations, merged and late-bound symbols, aliases, exports,
+// 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 { isAmbientModule, isGlobalScopeAugmentation, nodeIsMissing } from './ast-utilities.js';
+import { CodePoints, distanceToCandidate, utf8Length } from './spelling.js';
+import { setValueDeclaration } from './binder.js';
+import { checkResolvedBlockScopedVariable, getEmitStandardClassFields } from './checker-declaration-order.js';
+import { declarationNameToString, getNameOfDeclaration, getRootDeclaration, getSourceFileOfNode, getSourceTextOfNode, getDeclarationOfKind, getThisContainer, hasStaticModifier, isClassLike, isEntityNameExpression, isExternalOrCommonJSModule, isPartOfTypeQuery, isStatic, } from './binder-utilities.js';
+import { compareDiagnostics } from './diagnostics.js';
+import { NameResolver } from './name-resolver.js';
+import { Symbol, addDeclaration, getSymbolId, } from './symbol.js';
+import { createDiagnosticForNode } from './checker.js';
+import { compareSymbols } from './checker-type-factory.js';
+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 { getLateBindableNameOfDeclaration, getPropertyNameFromType, isTypeUsableAsPropertyName, hasLateBindableName, hasLateBindableIndexSignature, } from './checker-utilities.js';
+import { checkTypeOnlyAliasUse, markAliasDeclarationOfNameIfTypeOnly, getExportsOfModuleWorker, getTargetOfAliasDeclaration, getTypeOnlyAliasDeclaration, isTypeOnlyImportOrExportDeclaration, resolveExternalModuleNameWorker, resolveExternalModuleSymbol, resolveIndirectionAlias, } from './checker-modules.js';
+import { isJSAliasDeclaration } from './checker-javascript.js';
+import { getFeatureMap } from './checker-features.js';
+// ---- Name resolution
+/** The binder's name resolver with the checker's merging, alias handling and errors. */
+export class CheckerNameResolver extends NameResolver {
+    checker;
+    constructor(checker) {
+        super(checker.compilerOptions);
+        this.checker = checker;
+        this.globals = checker.globals;
+        this.argumentsSymbol = checker.argumentsSymbol;
+        this.requireSymbol = checker.requireSymbol;
+    }
+    lookup(symbols, name, meaning) {
+        return getSymbolOfMeaning(this.checker, symbols, name, meaning);
+    }
+    getSymbolOfDeclaration(node) {
+        return getSymbolOfDeclaration(this.checker, node);
+    }
+    error(location, message, args) {
+        this.checker.error(location, message, ...args);
+    }
+    symbolReferenced(symbol, meaning) {
+        const kinds = this.checker.symbolReferenceKinds;
+        const id = getSymbolId(symbol);
+        kinds.set(id, kinds.get(id) | meaning);
+    }
+    getRequiresScopeChangeCache(node) {
+        return (this.checker.existingNodeLinks(node)?.declarationRequiresScopeChange ?? 0);
+    }
+    setRequiresScopeChangeCache(node, value) {
+        this.checker.nodeLinks(node).declarationRequiresScopeChange = value;
+    }
+    /**
+     * A property initializer that references a local of the constructor, where the initializer is emitted
+     * when class fields aren't standard: reports a missing `this.` when the name resolves to nothing, else
+     * that the initializer (or the property's type) can't reference it.
+     */
+    onPropertyWithInvalidInitializer(location, name, declaration, result) {
+        const c = this.checker;
+        if (getEmitStandardClassFields(c))
+            return false;
+        if (result === undefined && checkAndReportErrorForMissingPrefix(c, location, name))
+            return true;
+        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);
+        return true;
+    }
+    onFailedToResolveSymbol(location, name, meaning, message) {
+        onFailedToResolveSymbol(this.checker, location, name, meaning, message);
+    }
+    onSuccessfullyResolvedSymbol(location, result, meaning, lastLocation, associatedDeclarationForContainingInitializerOrBindingName, withinDeferredContext) {
+        const c = this.checker;
+        const isInExternalModule = lastLocation !== undefined &&
+            lastLocation.kind === 307 /* 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`.
+        if (location !== undefined &&
+            ((meaning & 2 /* SymbolFlags.BlockScopedVariable */) !== 0 ||
+                ((meaning & (32 /* SymbolFlags.Class */ | 384 /* SymbolFlags.Enum */)) !== 0 &&
+                    (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */)))
+            checkResolvedBlockScopedVariable(this.checker, result, location);
+        // A module can't reference the value of a UMD global (`export as namespace`).
+        if (isInExternalModule &&
+            location !== undefined &&
+            (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */ &&
+            (location.flags & 4194304 /* NodeFlags.JSDoc */) === 0) {
+            const merged = getMergedSymbol(c, result);
+            if (merged.declarations.length !== 0 &&
+                merged.declarations.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]));
+        }
+        // A parameter initializer or binding name can't reference its own parameter or the ones after it.
+        const associated = associatedDeclarationForContainingInitializerOrBindingName;
+        if (location !== undefined &&
+            associated !== undefined &&
+            !withinDeferredContext &&
+            (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */) {
+            const candidate = getMergedSymbol(c, getLateBoundSymbol(c, result));
+            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)));
+            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));
+        }
+        if (location !== undefined && (meaning & 111551 /* SymbolFlags.Value */) !== 0)
+            checkTypeOnlyAliasUse(this.checker, location, result, result.name);
+        // Under isolatedModules, a value import named like a global value that the file uses must be type-only.
+        if (c.compilerOptions.isolatedModules === true &&
+            isInExternalModule &&
+            (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */) {
+            const name = result.name;
+            const isGlobal = getSymbolOfMeaning(c, c.globals, name, meaning) === result;
+            const locals = isGlobal ? getLocals(lastLocation) : undefined;
+            const nonValueSymbol = locals !== undefined ? getSymbolOfMeaning(c, locals, name, ~111551 /* SymbolFlags.Value */) : undefined;
+            if (nonValueSymbol !== undefined) {
+                const importDeclaration = nonValueSymbol.declarations.find((d) => d.kind === 277 /* SyntaxKind.ImportSpecifier */ ||
+                    d.kind === 274 /* SyntaxKind.ImportClause */ ||
+                    d.kind === 275 /* SyntaxKind.NamespaceImport */ ||
+                    d.kind === 272 /* 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);
+            }
+        }
+    }
+}
+export function resolveName(c, location, name, meaning, nameNotFoundMessage, isUse, excludeGlobals) {
+    return c.resolver.resolve(location, name, meaning, nameNotFoundMessage, isUse, excludeGlobals);
+}
+/** `symbols[name]` (merged) if it has `meaning`, directly or through an alias. */
+export function getSymbolOfMeaning(c, symbols, name, meaning) {
+    if ((meaning & 1073741823 /* SymbolFlags.All */) === 0)
+        return undefined;
+    const found = symbols.get(name);
+    if (found === undefined)
+        return undefined;
+    const symbol = getMergedSymbol(c, found);
+    if ((symbol.flags & meaning) !== 0)
+        return symbol;
+    // getSymbolFlags is All when alias resolution failed, which avoids cascading errors.
+    if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && (getSymbolFlags(c, symbol) & meaning) !== 0)
+        return symbol;
+    return undefined;
+}
+function isPrimitiveTypeName(name) {
+    return (name === 'any' ||
+        name === 'string' ||
+        name === 'number' ||
+        name === 'boolean' ||
+        name === 'never' ||
+        name === 'unknown');
+}
+function isES2015OrLaterConstructorName(name) {
+    return (name === 'Promise' ||
+        name === 'Symbol' ||
+        name === 'Map' ||
+        name === 'WeakMap' ||
+        name === 'Set' ||
+        name === 'WeakSet');
+}
+function onFailedToResolveSymbol(c, location, name, meaning, message) {
+    let declarationName = name;
+    if (location !== undefined) {
+        if (location.parent !== undefined && location.parent.kind === 319 /* SyntaxKind.JSDocLink */)
+            return;
+        if (checkAndReportErrorForMissingPrefix(c, location, name) ||
+            checkAndReportErrorForExtendingInterface(c, location) ||
+            checkAndReportErrorForUsingTypeAsNamespace(c, location, name, meaning) ||
+            checkAndReportErrorForExportingPrimitiveType(c, location, name) ||
+            checkAndReportErrorForUsingNamespaceAsTypeOrValue(c, location, name, meaning) ||
+            checkAndReportErrorForUsingTypeAsValue(c, location, name, meaning) ||
+            checkAndReportErrorForUsingValueAsType(c, location, name, meaning))
+            return;
+        if (location.kind === 79 /* SyntaxKind.Identifier */ && getText(location) === name)
+            declarationName = declarationNameToString(getSourceFileOfNode(location), location);
+    }
+    // A missing library comes before spelling suggestions.
+    const features = getFeatureMap().get(name);
+    if (features !== undefined) {
+        c.error(location, message, declarationName, features[0].lib);
+        return;
+    }
+    const suggestion = c.suggestionResolver.resolve(location, name, meaning, undefined, false, false);
+    if (suggestion !== undefined &&
+        !(suggestion.valueDeclaration !== undefined &&
+            isAmbientModule(suggestion.valueDeclaration) &&
+            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]);
+        if (suggestion.valueDeclaration !== undefined)
+            diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [suggestionName]));
+        c.addDiagnostic(diagnostic);
+        return;
+    }
+    c.error(location, message, declarationName);
+}
+function checkAndReportErrorForMissingPrefix(c, location, name) {
+    if (location.kind !== 79 /* SyntaxKind.Identifier */ ||
+        getText(location) !== name ||
+        isTypeReferenceIdentifier(location) ||
+        isPartOfTypeQuery(location))
+        return false;
+    const container = getThisContainer(location, false, false);
+    for (let current = container; current.parent !== undefined; current = current.parent) {
+        if (!isClassLike(current.parent))
+            continue;
+        const classSymbol = getSymbolOfDeclaration(c, current.parent);
+        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));
+            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);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isTypeReferenceIdentifier(node) {
+    let current = node;
+    while (current.parent !== undefined && current.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        current = current.parent;
+    return current.parent !== undefined && current.parent.kind === 184 /* 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));
+        return true;
+    }
+    return false;
+}
+function getEntityNameForExtendingInterface(node) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return node.parent !== undefined ? getEntityNameForExtendingInterface(node.parent) : undefined;
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */: {
+            const expression = getExpression(node);
+            return isEntityNameExpression(expression, false) ? expression : undefined;
+        }
+    }
+    return undefined;
+}
+/** Resolves names to their closest misspelling in scope, for "Did you mean" suggestions. */
+export class SuggestionNameResolver extends CheckerNameResolver {
+    lookup(symbols, name, meaning) {
+        const symbol = getSymbolOfMeaning(this.checker, symbols, name, meaning);
+        if (symbol !== undefined)
+            return symbol;
+        const candidates = [];
+        for (const s of symbols.values())
+            candidates.push(s);
+        if ((meaning & 1073741824 /* SymbolFlags.GlobalLookup */) !== 0) {
+            for (const builtin of primitiveBuiltins.split(' '))
+                if (symbols.has(builtin))
+                    candidates.push(getPrimitiveTypeAliasSuggestion(this.checker, primitiveTypeAliasFor(builtin)));
+        }
+        return getSpellingSuggestionForName(this.checker, name, candidates, meaning);
+    }
+    error(_location, _message, _args) { }
+    symbolReferenced(_symbol, _meaning) { }
+    onFailedToResolveSymbol(_location, _name, _meaning, _message) { }
+}
+/** The primitive type alias suggested for a misspelled builtin wrapper name, or ''. */
+function primitiveTypeAliasFor(builtin) {
+    switch (builtin) {
+        case 'String':
+            return 'string';
+        case 'Number':
+            return 'number';
+        case 'Boolean':
+            return 'boolean';
+        case 'Object':
+            return 'object';
+        case 'BigInt':
+            return 'bigint';
+        case 'Symbol':
+            return 'symbol';
+    }
+    return '';
+}
+const primitiveBuiltins = 'String Number Boolean Object BigInt Symbol';
+function getPrimitiveTypeAliasSuggestion(c, name) {
+    let symbol = c.primitiveTypeAliasSuggestions.get(name);
+    if (symbol === undefined) {
+        symbol = c.newSymbol(524288 /* SymbolFlags.TypeAlias */, name);
+        c.primitiveTypeAliasSuggestions.set(name, symbol);
+    }
+    return symbol;
+}
+/** The symbol whose name is closest to `name` and that has `meaning`, if close enough. */
+export function getSpellingSuggestionForName(c, name, symbols, meaning) {
+    const nameCodePoints = new CodePoints();
+    nameCodePoints.set(name);
+    const maximumLengthDifference = Math.max(2, Math.floor(nameCodePoints.length * 0.34));
+    let bestDistance = Math.floor(nameCodePoints.length * 0.4) + 0.9;
+    let best = undefined;
+    const lowerName = name.toLowerCase();
+    for (const candidate of symbols) {
+        const candidateName = getCandidateName(c, candidate, meaning);
+        if (candidateName === '')
+            continue;
+        // tsgo measures candidates in bytes and the name in code points. A candidate has at least as
+        // many bytes as UTF-16 units, so most long candidates are out without measuring them.
+        if (candidateName.length - nameCodePoints.length > maximumLengthDifference)
+            continue;
+        const candidateLength = utf8Length(candidateName);
+        if (Math.max(candidateLength, nameCodePoints.length) - Math.min(candidateLength, nameCodePoints.length) >
+            maximumLengthDifference)
+            continue;
+        if (candidateName === name)
+            continue;
+        if (candidateLength < 3 && candidateName.toLowerCase() !== lowerName)
+            continue;
+        const distance = distanceToCandidate(nameCodePoints, candidateName, bestDistance);
+        if (distance < 0)
+            continue;
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = candidate;
+        }
+        else if (best === undefined || compareSymbols(c, candidate, best) < 0)
+            best = candidate;
+    }
+    return best;
+}
+function getCandidateName(c, candidate, meaning) {
+    const name = candidate.name;
+    if (name.length === 0 || name.charCodeAt(0) === 0x22 || name.charCodeAt(0) === 0xfffe)
+        return '';
+    if ((candidate.flags & meaning) !== 0)
+        return name;
+    if ((candidate.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+        const target = tryResolveAlias(c, candidate);
+        if (target !== undefined && (target.flags & meaning) !== 0)
+            return name;
+    }
+    return '';
+}
+function checkAndReportErrorForUsingTypeAsNamespace(c, location, name, meaning) {
+    if (meaning !== 1920 /* SymbolFlags.Namespace */)
+        return false;
+    const symbol = resolveSymbol(c, resolveName(c, location, name, 788968 /* SymbolFlags.Type */ & ~1920 /* SymbolFlags.Namespace */, undefined, false, false));
+    if (symbol === undefined)
+        return false;
+    const parent = location.parent;
+    if (parent !== undefined && parent.kind === 167 /* SyntaxKind.QualifiedName */) {
+        const propName = parent.right.text;
+        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);
+            return true;
+        }
+    }
+    c.error(location, 834 /* 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);
+        return true;
+    }
+    return false;
+}
+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);
+            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);
+            return true;
+        }
+    }
+    return false;
+}
+function checkAndReportErrorForUsingTypeAsValue(c, location, name, meaning) {
+    if ((meaning & 111551 /* SymbolFlags.Value */) === 0)
+        return false;
+    if (isPrimitiveTypeName(name)) {
+        const grandparent = location.parent?.parent;
+        if (grandparent !== undefined &&
+            grandparent.parent !== undefined &&
+            grandparent.kind === 299 /* 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);
+            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);
+            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);
+        }
+        else
+            c.error(location, 825 /* 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) {
+        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);
+        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');
+        else
+            c.error(location, 825 /* Diagnostics.X_0_only_refers_to_a_type_but_is_being_used_as_a_value_here */, name);
+        return true;
+    }
+    return false;
+}
+function maybeMappedType(c, node, symbol) {
+    let container = node.parent;
+    while (container !== undefined &&
+        (container.kind === 168 /* SyntaxKind.ComputedPropertyName */ || container.kind === 172 /* SyntaxKind.PropertySignature */))
+        container = container.parent;
+    if (container === undefined || container.kind !== 188 /* SyntaxKind.TypeLiteral */)
+        return false;
+    const members = getMemberNodes(container);
+    if (members === undefined || members.nodes.length !== 1)
+        return false;
+    const type = getDeclaredTypeOfSymbol(c, symbol);
+    if ((type.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return false;
+    for (const t of type.types)
+        if (!isTypeAssignableToKindEx(c, t, 3072 /* TypeFlags.StringOrNumberLiteral */, true))
+            return false;
+    return true;
+}
+function checkAndReportErrorForUsingValueAsType(c, location, name, meaning) {
+    if ((meaning & (788968 /* SymbolFlags.Type */ & ~1920 /* SymbolFlags.Namespace */)) === 0)
+        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);
+        return true;
+    }
+    return false;
+}
+// ---- Merging
+function mergeFileGlobals(c, file) {
+    if (!isExternalOrCommonJSModule(file)) {
+        const locals = file.locals;
+        if (locals !== undefined) {
+            const fileGlobalThis = locals.get('globalThis');
+            if (fileGlobalThis !== undefined)
+                for (const d of fileGlobalThis.declarations)
+                    c.addDiagnostic(createDiagnosticForNode(d, 568 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, [
+                        'globalThis',
+                    ]));
+            for (const symbol of locals.values()) {
+                if ((symbol.flags & 1536 /* SymbolFlags.Module */) !== 0 && isAmbientModuleSymbolName(symbol.name))
+                    c.ambientModuleSymbols.push(symbol);
+                else
+                    mergeGlobalSymbol(c, symbol);
+            }
+        }
+    }
+    for (const pattern of file.patternAmbientModules)
+        c.patternAmbientModules.push(pattern);
+    if (file.symbol !== undefined && file.globalExports !== undefined)
+        // UMD exports, first in wins.
+        for (const [name, symbol] of file.globalExports)
+            if (!c.globals.has(name))
+                setGlobal(c, name, symbol);
+}
+/** Changes to a map, recorded so that they can be undone. */
+export class TableChanges {
+    added = new Set();
+    replaced = new Map();
+    set(table, key, value) {
+        const previous = table.get(key);
+        if (previous === undefined)
+            this.added.add(key);
+        else if (!this.added.has(key) && !this.replaced.has(key))
+            this.replaced.set(key, previous);
+        table.set(key, value);
+    }
+    /** Restores `table`, or a copy of it, to its state before the changes. */
+    undo(table) {
+        for (const key of this.added)
+            table.delete(key);
+        for (const [key, value] of this.replaced)
+            table.set(key, value);
+    }
+}
+/**
+ * Globals merged from the locals of a program's leading default libraries. Checkers of programs
+ * with the same libraries start from them; a later merge into a shared symbol merges into a copy.
+ * One checker at a time borrows the tables and changes them in place; the others copy them.
+ */
+export class LibGlobals {
+    files;
+    globals;
+    mergedSymbols;
+    ambientModuleSymbols;
+    patternAmbientModules;
+    /** Ids of the symbols merged into each shared symbol. */
+    sources = new Map();
+    /** The checker using `globals` and `mergedSymbols` in place. */
+    borrower = undefined;
+    constructor(c, files) {
+        this.files = files;
+        this.globals = new Map(c.globals);
+        // Each checker sets its own `globalThis`, keeping it first.
+        this.globals.set(c.globalThisSymbol.name, new Symbol(0 /* SymbolFlags.None */, 'globalThis'));
+        this.mergedSymbols = new Map(c.mergedSymbols);
+        this.ambientModuleSymbols = c.ambientModuleSymbols.slice();
+        this.patternAmbientModules = c.patternAmbientModules.slice();
+        for (const [id, target] of this.mergedSymbols) {
+            let ids = this.sources.get(target);
+            if (ids === undefined) {
+                ids = [];
+                this.sources.set(target, ids);
+            }
+            ids.push(id);
+        }
+    }
+    copyGlobals() {
+        const globals = new Map(this.globals);
+        if (this.borrower !== undefined)
+            this.borrower.globalChanges.undo(globals);
+        return globals;
+    }
+    copyMergedSymbols() {
+        const mergedSymbols = new Map(this.mergedSymbols);
+        if (this.borrower !== undefined)
+            this.borrower.mergedSymbolChanges.undo(mergedSymbols);
+        return mergedSymbols;
+    }
+    /** Whether `files` starts with exactly these `count` libraries. */
+    matches(files, count) {
+        if (count !== this.files.length)
+            return false;
+        for (let i = 0; i < count; i++)
+            if (files[i] !== this.files[i])
+                return false;
+        return true;
+    }
+}
+/**
+ * The globals, merged symbols and module augmentations of a whole program, as one checker merged
+ * them before checker threads share the program (parallel-check.ts). Other checkers of the program
+ * start from copies of the tables and add the diagnostics the merges reported; the merged symbols
+ * are shared, and a later merge into one merges into a copy.
+ */
+export class MergedGlobals {
+    globals;
+    mergedSymbols;
+    ambientModuleSymbols;
+    patternAmbientModules;
+    patternAmbientModuleAugmentations;
+    /** Whether the global `undefined` is the checker's own (no declaration of `undefined` merged). */
+    ownUndefined;
+    /** Ids of the symbols merged into each shared symbol. */
+    sources = new Map();
+    /** Copies of the checker's `mergeDiagnostics`. */
+    diagnostics = [];
+    constructor(c) {
+        this.globals = new Map(c.globals);
+        // Each checker sets its own `globalThis` and `undefined`, in the same places in the table.
+        this.globals.set(c.globalThisSymbol.name, new Symbol(0 /* SymbolFlags.None */, 'globalThis'));
+        this.ownUndefined = c.globals.get('undefined') === c.undefinedSymbol;
+        if (this.ownUndefined)
+            this.globals.set('undefined', new Symbol(0 /* SymbolFlags.None */, 'undefined'));
+        for (const symbol of this.globals.values())
+            getSymbolId(symbol);
+        this.mergedSymbols = new Map(c.mergedSymbols);
+        this.ambientModuleSymbols = c.ambientModuleSymbols.slice();
+        this.patternAmbientModules = c.patternAmbientModules.slice();
+        this.patternAmbientModuleAugmentations = new Map(c.patternAmbientModuleAugmentations);
+        for (const [id, target] of this.mergedSymbols) {
+            let ids = this.sources.get(target);
+            if (ids === undefined) {
+                // Shared symbols are never written, so they need their ids now.
+                getSymbolId(target);
+                ids = [];
+                this.sources.set(target, ids);
+            }
+            ids.push(id);
+        }
+        // The checker can add related information to its diagnostics later.
+        for (const list of c.mergeDiagnostics)
+            this.diagnostics.push(copyDiagnostics(list));
+    }
+}
+function copyDiagnostics(list) {
+    const result = [];
+    for (const diagnostic of list) {
+        const copy = diagnostic.clone();
+        copy.relatedInformation = diagnostic.relatedInformation.slice();
+        result.push(copy);
+    }
+    return result;
+}
+/** Adds the diagnostics and suggestions of `merged`'s merge `step` (0: globals, 1: augmentations). */
+function addMergeDiagnostics(c, merged, step) {
+    for (const diagnostic of copyDiagnostics(merged.diagnostics[2 * step]))
+        c.diagnostics.add(diagnostic);
+    for (const diagnostic of copyDiagnostics(merged.diagnostics[2 * step + 1]))
+        c.suggestionDiagnostics.add(diagnostic);
+}
+/**
+ * Shares the globals and module augmentations `c` merged with the other checkers of its program;
+ * `c` treats its merged symbols as shared from now on.
+ */
+export function shareMergedGlobals(c) {
+    const merged = new MergedGlobals(c);
+    c.mergedGlobals = merged;
+    return merged;
+}
+/** The ids of the symbols merged into `symbol`, if it is shared with other checkers. */
+function sharedSources(c, symbol) {
+    const merged = c.mergedGlobals;
+    const ids = merged !== undefined ? merged.sources.get(symbol) : undefined;
+    if (ids !== undefined)
+        return ids;
+    const libs = c.libGlobals;
+    return libs !== undefined ? libs.sources.get(symbol) : undefined;
+}
+const libGlobalsCache = [];
+/** Drops the shared library globals (a rebuild reparses the library files). */
+export function clearLibGlobalsCache() {
+    libGlobalsCache.length = 0;
+}
+/** Drops the shared library globals merged from any of `files`, for a program that is no longer used. */
+export function dropLibGlobals(files) {
+    const dropped = new Set(files);
+    for (let i = libGlobalsCache.length - 1; i >= 0; i--)
+        if (dropped.has(libGlobalsCache[i].files[0]))
+            libGlobalsCache.splice(i, 1);
+}
+/** Number of leading default library files, whose merged locals can be shared. */
+function getLibraryCount(c) {
+    const files = c.files;
+    let count = 0;
+    while (count < files.length && c.host.isSourceFileDefaultLibrary(files[count]))
+        count++;
+    return count;
+}
+/** The shared globals of the checker's default libraries, if another checker merged them. */
+export function findLibGlobals(c) {
+    const count = getLibraryCount(c);
+    if (count > 0)
+        for (const libs of libGlobalsCache)
+            if (libs.matches(c.files, count))
+                return libs;
+    return undefined;
+}
+export function borrowLibGlobals(c, libs) {
+    libs.borrower = c;
+    c.globalChanges = new TableChanges();
+    c.mergedSymbolChanges = new TableChanges();
+}
+/** Undoes a disposed checker's changes to the tables it borrowed. */
+export function returnLibGlobals(c) {
+    const libs = c.libGlobals;
+    c.globalChanges.undo(libs.globals);
+    c.mergedSymbolChanges.undo(libs.mergedSymbols);
+    c.globalChanges = undefined;
+    c.mergedSymbolChanges = undefined;
+    libs.borrower = undefined;
+}
+export function setGlobal(c, name, symbol) {
+    if (c.globalChanges !== undefined)
+        c.globalChanges.set(c.globals, name, symbol);
+    else
+        c.globals.set(name, symbol);
+}
+function setMergedSymbol(c, id, target) {
+    if (c.mergedSymbolChanges !== undefined)
+        c.mergedSymbolChanges.set(c.mergedSymbols, id, target);
+    else
+        c.mergedSymbols.set(id, target);
+}
+/** Merges script locals into globals; ambient modules and augmentations wait for global types. */
+export function initializeGlobals(c) {
+    const globals = c.globals;
+    const merged = c.mergedGlobals;
+    if (merged !== undefined) {
+        // The constructor copied the globals and merged symbols.
+        for (const symbol of merged.ambientModuleSymbols)
+            c.ambientModuleSymbols.push(symbol);
+        for (const pattern of merged.patternAmbientModules)
+            c.patternAmbientModules.push(pattern);
+        for (const [name, symbol] of merged.patternAmbientModuleAugmentations)
+            c.patternAmbientModuleAugmentations.set(name, symbol);
+        addMergeDiagnostics(c, merged, 0);
+        if (merged.ownUndefined)
+            setGlobal(c, 'undefined', c.undefinedSymbol);
+        return;
+    }
+    const libraryCount = getLibraryCount(c);
+    const libs = c.libGlobals;
+    if (libs !== undefined) {
+        // The constructor copied the globals and merged symbols.
+        for (const symbol of libs.ambientModuleSymbols)
+            c.ambientModuleSymbols.push(symbol);
+        for (const pattern of libs.patternAmbientModules)
+            c.patternAmbientModules.push(pattern);
+    }
+    else if (libraryCount > 0) {
+        const diagnosticCount = c.diagnostics.count();
+        for (let i = 0; i < libraryCount; i++)
+            mergeFileGlobals(c, c.files[i]);
+        // Diagnostics belong to one checker, so libraries that report any aren't shared.
+        if (c.diagnostics.count() === diagnosticCount) {
+            c.libGlobals = new LibGlobals(c, c.files.slice(0, libraryCount));
+            libGlobalsCache.push(c.libGlobals);
+        }
+    }
+    for (let i = libraryCount; i < c.files.length; i++)
+        mergeFileGlobals(c, c.files[i]);
+    for (const file of c.files)
+        for (const augmentation of file.moduleAugmentations)
+            if (augmentation.parent !== undefined && isGlobalScopeAugmentation(augmentation.parent))
+                mergeModuleAugmentation(c, augmentation);
+    // addUndefinedToGlobalsOrErrorOnRedeclaration
+    const target = globals.get('undefined');
+    if (target !== undefined) {
+        for (const declaration of target.declarations)
+            if (!isTypeDeclaration(declaration))
+                c.addDiagnostic(createDiagnosticForNode(declaration, 568 /* Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0 */, ['undefined']));
+    }
+    else
+        setGlobal(c, 'undefined', c.undefinedSymbol);
+}
+export function mergeAmbientModulesAndAugmentations(c) {
+    const merged = c.mergedGlobals;
+    if (merged !== undefined) {
+        addMergeDiagnostics(c, merged, 1);
+        return;
+    }
+    for (const symbol of c.ambientModuleSymbols)
+        mergeGlobalSymbol(c, symbol);
+    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;
+}
+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 */:
+            return true;
+        case 274 /* SyntaxKind.ImportClause */:
+            return getIsTypeOnly(node);
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return getIsTypeOnly(node);
+    }
+    return false;
+}
+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));
+}
+function mergeModuleAugmentation(c, moduleName) {
+    const moduleNode = moduleName.parent;
+    const augmentationSymbol = moduleNode.symbol;
+    // Several augmentations in one file share a symbol; merge it once.
+    if (augmentationSymbol.declarations[0] !== moduleNode)
+        return;
+    if (isGlobalScopeAugmentation(moduleNode)) {
+        if (augmentationSymbol.exports !== undefined)
+            mergeSymbolTable(c, c.globals, augmentationSymbol.exports, false, undefined);
+        return;
+    }
+    const moduleNotFoundError = (moduleNode.parent.flags & 8388608 /* NodeFlags.Ambient */) === 0
+        ? 798 /* Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found */
+        : undefined;
+    let mainModule = resolveExternalModuleNameWorker(c, moduleName, moduleName, moduleNotFoundError, false, true);
+    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) {
+                const merged = mergeSymbol(c, augmentationSymbol, mainModule, true);
+                c.patternAmbientModuleAugmentations.set(getText(moduleName), merged);
+                return;
+            }
+        // Exports the module gets through `export *` live on the re-exported symbols; merge into those.
+        const mainExports = mainModule.exports;
+        const exports = augmentationSymbol.exports;
+        if (mainExports !== undefined &&
+            mainExports.has("\uFFFEexport" /* InternalSymbolName.ExportStar */) &&
+            exports !== undefined &&
+            exports.size > 0) {
+            const resolvedExports = getExportsOfModuleWorker(c, mainModule);
+            for (const [id, symbol] of exports) {
+                const resolved = resolvedExports.get(id);
+                if (resolved !== undefined && !mainExports.has(id))
+                    mergeSymbol(c, resolved, symbol, false);
+            }
+        }
+        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));
+}
+export function mergeSymbolTable(c, target, source, unidirectional, mergedParent) {
+    for (const [id, sourceSymbol] of source) {
+        const targetSymbol = target.get(id);
+        const merged = targetSymbol !== undefined
+            ? mergeSymbol(c, targetSymbol, sourceSymbol, unidirectional)
+            : getMergedSymbol(c, sourceSymbol);
+        // A merged symbol takes the parent that initiated the merge of its exports.
+        if (mergedParent !== undefined && targetSymbol !== undefined && (merged.flags & 33554432 /* SymbolFlags.Transient */) !== 0)
+            merged.parent = mergedParent;
+        if (target === c.globals)
+            setGlobal(c, id, merged);
+        else
+            target.set(id, merged);
+    }
+}
+/** Merges `source` into `target`, cloning a non-transient target first. */
+export function mergeSymbol(c, target, source, unidirectional) {
+    if ((target.flags & getExcludedSymbolFlags(source.flags)) === 0 ||
+        ((source.flags | target.flags) & 67108864 /* SymbolFlags.Assignment */) !== 0) {
+        if (source === target)
+            return target;
+        if ((target.flags & 33554432 /* SymbolFlags.Transient */) === 0) {
+            const resolvedTarget = resolveSymbol(c, target);
+            if (resolvedTarget === c.unknownSymbol)
+                return source;
+            if ((resolvedTarget.flags & getExcludedSymbolFlags(source.flags)) === 0 ||
+                ((source.flags | resolvedTarget.flags) & 67108864 /* SymbolFlags.Assignment */) !== 0)
+                target = cloneSymbol(c, resolvedTarget);
+            else {
+                reportMergeSymbolError(c, target, source);
+                return source;
+            }
+        }
+        else if (sharedSources(c, target) !== undefined)
+            target = copySharedSymbol(c, target);
+        if ((source.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+            (target.flags & 512 /* SymbolFlags.ValueModule */) !== 0 &&
+            (target.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) !== 0 &&
+            (source.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) === 0)
+            target.flags &= ~268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+        let sourceFlags = source.flags;
+        if ((target.flags & 268435456 /* SymbolFlags.ConstEnumOnlyModule */) === 0)
+            sourceFlags &= ~268435456 /* SymbolFlags.ConstEnumOnlyModule */;
+        target.flags |= sourceFlags;
+        if (source.valueDeclaration !== undefined)
+            setValueDeclaration(target, source.valueDeclaration);
+        for (const d of source.declarations)
+            addDeclaration(target, d);
+        if (source.members !== undefined) {
+            if (target.members === undefined)
+                target.members = new Map();
+            mergeSymbolTable(c, target.members, source.members, unidirectional, undefined);
+        }
+        if (source.exports !== undefined) {
+            if (target.exports === undefined)
+                target.exports = new Map();
+            mergeSymbolTable(c, target.exports, source.exports, unidirectional, target);
+        }
+        if (!unidirectional)
+            recordMergedSymbol(c, target, source);
+    }
+    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.declarations[0]), 783 /* Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity */, symbolToString(c, target));
+    }
+    else
+        reportMergeSymbolError(c, target, source);
+    return target;
+}
+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 */
+        : isEitherBlockScoped
+            ? 619 /* Diagnostics.Cannot_redeclare_block_scoped_variable_0 */
+            : 478 /* Diagnostics.Duplicate_identifier_0 */;
+    const name = symbolToString(c, source);
+    if (!isPlainJSFile(source))
+        addDuplicateDeclarationErrors(c, source, message, name, target);
+    if (!isPlainJSFile(target))
+        addDuplicateDeclarationErrors(c, target, message, name, source);
+}
+function isPlainJSFile(symbol) {
+    if (symbol.declarations.length === 0)
+        return false;
+    const file = getSourceFileOfNode(symbol.declarations[0]);
+    return file.isJS() && file.checkJsDirective === undefined;
+}
+function addDuplicateDeclarationErrors(c, target, message, name, source) {
+    for (const node of target.declarations)
+        addDuplicateDeclarationError(c, node, message, name, source.declarations);
+}
+export function addDuplicateDeclarationError(c, node, message, name, relatedNodes) {
+    const errorNode = getNameOfDeclaration(node) ?? node;
+    const error = lookupOrIssueError(c, errorNode, message, [name]);
+    for (const relatedNode of relatedNodes) {
+        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 related = error.relatedInformation;
+        if (related.length >= 5 || hasMatchingDiagnostic(related, leading, followOn))
+            continue;
+        error.addRelatedInfo(related.length === 0 ? leading : followOn);
+    }
+}
+function hasMatchingDiagnostic(diagnostics, a, b) {
+    for (const d of diagnostics)
+        if (compareDiagnostics(d, b) === 0 || compareDiagnostics(d, a) === 0)
+            return true;
+    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;
+}
+export function getExcludedSymbolFlags(flags) {
+    let result = 0;
+    if ((flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
+        result |= 111551 /* SymbolFlags.BlockScopedVariableExcludes */;
+    if ((flags & 1 /* SymbolFlags.FunctionScopedVariable */) !== 0)
+        result |= 111550 /* SymbolFlags.FunctionScopedVariableExcludes */;
+    if ((flags & 4 /* SymbolFlags.Property */) !== 0)
+        result |= 13243 /* SymbolFlags.PropertyExcludes */;
+    if ((flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+        result |= 900095 /* SymbolFlags.EnumMemberExcludes */;
+    if ((flags & 16 /* SymbolFlags.Function */) !== 0)
+        result |= 110991 /* SymbolFlags.FunctionExcludes */;
+    if ((flags & 32 /* SymbolFlags.Class */) !== 0)
+        result |= 899503 /* SymbolFlags.ClassExcludes */;
+    if ((flags & 64 /* SymbolFlags.Interface */) !== 0)
+        result |= 788872 /* SymbolFlags.InterfaceExcludes */;
+    if ((flags & 256 /* SymbolFlags.RegularEnum */) !== 0)
+        result |= 899327 /* SymbolFlags.RegularEnumExcludes */;
+    if ((flags & 128 /* SymbolFlags.ConstEnum */) !== 0)
+        result |= 899967 /* SymbolFlags.ConstEnumExcludes */;
+    if ((flags & 512 /* SymbolFlags.ValueModule */) !== 0)
+        result |= 110735 /* SymbolFlags.ValueModuleExcludes */;
+    if ((flags & 8192 /* SymbolFlags.Method */) !== 0)
+        result |= 103359 /* SymbolFlags.MethodExcludes */;
+    if ((flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
+        result |= 46011 /* SymbolFlags.GetAccessorExcludes */;
+    if ((flags & 65536 /* SymbolFlags.SetAccessor */) !== 0)
+        result |= 78779 /* SymbolFlags.SetAccessorExcludes */;
+    if ((flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
+        result |= 526824 /* SymbolFlags.TypeParameterExcludes */;
+    if ((flags & 524288 /* SymbolFlags.TypeAlias */) !== 0)
+        result |= 788968 /* SymbolFlags.TypeAliasExcludes */;
+    if ((flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        result |= 2097152 /* SymbolFlags.AliasExcludes */;
+    if ((flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) !== 0)
+        result &= ~8192 /* SymbolFlags.Method */;
+    return result;
+}
+export function cloneSymbol(c, symbol) {
+    const result = c.newSymbol(symbol.flags, symbol.name);
+    result.declarations = symbol.declarations.slice();
+    result.parent = symbol.parent;
+    result.valueDeclaration = symbol.valueDeclaration;
+    if (symbol.members !== undefined)
+        result.members = new Map(symbol.members);
+    if (symbol.exports !== undefined)
+        result.exports = new Map(symbol.exports);
+    recordMergedSymbol(c, result, symbol);
+    return result;
+}
+/**
+ * A checker's own copy of a symbol shared through `LibGlobals`, which stands for it: the symbols
+ * merged into the shared one, and the shared one itself, now merge into the copy.
+ */
+function copySharedSymbol(c, shared) {
+    const result = c.newSymbol(shared.flags, shared.name);
+    result.declarations = shared.declarations.slice();
+    result.parent = shared.parent;
+    result.valueDeclaration = shared.valueDeclaration;
+    if (shared.members !== undefined)
+        result.members = new Map(shared.members);
+    if (shared.exports !== undefined)
+        result.exports = new Map(shared.exports);
+    c.sharedSymbolCopies.set(result, shared);
+    recordMergedSymbol(c, result, result);
+    return result;
+}
+function recordMergedSymbol(c, target, source) {
+    setMergedSymbol(c, getSymbolId(source), target);
+    // Merging a copy merges what it stands for.
+    const shared = c.sharedSymbolCopies.get(source);
+    if (shared !== undefined) {
+        setMergedSymbol(c, getSymbolId(shared), target);
+        for (const id of sharedSources(c, shared))
+            setMergedSymbol(c, id, target);
+    }
+}
+export function getMergedSymbol(c, symbol) {
+    const id = symbol.id;
+    if (id !== 0) {
+        const merged = c.mergedSymbols.get(id);
+        if (merged !== undefined)
+            return merged;
+    }
+    return symbol;
+}
+export function getParentOfSymbol(c, symbol) {
+    return symbol.parent !== undefined ? getMergedSymbol(c, getLateBoundSymbol(c, symbol.parent)) : undefined;
+}
+export function getExportSymbolOfValueSymbolIfExported(c, symbol) {
+    if ((symbol.flags & 1048576 /* SymbolFlags.ExportValue */) !== 0 && symbol.exportSymbol !== undefined)
+        symbol = symbol.exportSymbol;
+    return getMergedSymbol(c, symbol);
+}
+export function getSymbolOfDeclaration(c, node) {
+    const symbol = getSymbol(node);
+    return symbol !== undefined ? getMergedSymbol(c, getLateBoundSymbol(c, symbol)) : undefined;
+}
+function hasStaticDeclaration(symbol) {
+    for (const d of symbol.declarations)
+        if (hasStaticModifier(d))
+            return true;
+    return false;
+}
+export function getLateBoundSymbol(c, symbol) {
+    if ((symbol.flags & 106500 /* SymbolFlags.ClassMember */) === 0 || symbol.name !== "\uFFFEcomputed" /* InternalSymbolName.Computed */)
+        return symbol;
+    const links = c.symbolLinks(symbol);
+    if (links.lateSymbol === undefined && hasLateBindableDeclaration(c, symbol)) {
+        // Force late binding of the parent's members or exports, which sets lateSymbol.
+        if (symbol.parent !== undefined) {
+            const parent = getMergedSymbol(c, symbol.parent);
+            if (hasStaticDeclaration(symbol))
+                getExportsOfSymbol(c, parent);
+            else
+                getMembersOfSymbol(c, parent);
+        }
+        else {
+            // An `F[name] = …` assignment in a script has no parent. Checking its target late-binds it
+            // with the members of the function it's assigned to.
+            for (const declaration of symbol.declarations)
+                if (declaration instanceof BinaryExpression)
+                    checkExpressionCached(c, declaration.left);
+        }
+    }
+    if (links.lateSymbol === undefined)
+        links.lateSymbol = symbol;
+    return links.lateSymbol;
+}
+function hasLateBindableDeclaration(c, symbol) {
+    for (const declaration of symbol.declarations)
+        if (hasLateBindableName(c, declaration))
+            return true;
+    return false;
+}
+// ---- Global types
+export function getGlobalSymbol(c, name, meaning, diagnostic) {
+    // Without a location, missing globals are global diagnostics.
+    return resolveName(c, undefined, name, meaning, diagnostic, false, false);
+}
+function getGlobalTypeDeclaration(symbol) {
+    for (const d of symbol.declarations) {
+        switch (d.kind) {
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+                return d;
+        }
+    }
+    return undefined;
+}
+/** 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);
+    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));
+        }
+        else if (reportErrors)
+            c.error(getGlobalTypeDeclaration(symbol), 494 /* Diagnostics.Global_type_0_must_be_a_class_or_interface_type */, symbol.name);
+    }
+    return arity !== 0 ? c.emptyGenericType : c.emptyObjectType;
+}
+/** Memoized `getGlobalType`, keyed by name, arity and whether errors were reported. */
+export function getCachedGlobalType(c, name, arity, reportErrors) {
+    // By name, then by arity and whether errors are reported: callers pass literal names.
+    let byArity = c.globalTypeCache.get(name);
+    if (byArity === undefined) {
+        byArity = new Map();
+        c.globalTypeCache.set(name, byArity);
+    }
+    const slot = arity * 2 + (reportErrors ? 1 : 0);
+    let type = byArity.get(slot);
+    if (type === undefined) {
+        type = getGlobalType(c, name, arity, reportErrors);
+        byArity.set(slot, type);
+    }
+    return type;
+}
+export function getGlobalTypeAliasSymbol(c, name, arity, reportErrors) {
+    const key = 'alias:' + 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);
+    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));
+            }
+            symbol = undefined;
+        }
+    }
+    c.globalSymbolCache.set(key, symbol === undefined ? null : symbol);
+    return symbol;
+}
+export function getGlobalValueSymbol(c, name, reportErrors) {
+    const key = 'value:' + 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);
+    c.globalSymbolCache.set(key, symbol === undefined ? null : symbol);
+    return symbol;
+}
+export function getGlobalStrictFunctionType(c, name) {
+    return c.strictBindCallApply ? getGlobalType(c, name, 0, true) : c.globalFunctionType;
+}
+// ---- Aliases
+export function isNonLocalAlias(symbol, excludes) {
+    if (symbol === undefined)
+        return false;
+    return ((symbol.flags & (2097152 /* SymbolFlags.Alias */ | excludes)) === 2097152 /* SymbolFlags.Alias */ ||
+        ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && (symbol.flags & 67108864 /* SymbolFlags.Assignment */) !== 0));
+}
+export function resolveSymbol(c, symbol) {
+    if (symbol !== undefined && isNonLocalAlias(symbol, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */))
+        return resolveAlias(c, symbol);
+    return symbol;
+}
+export function resolveSymbolEx(c, symbol, dontResolveAlias) {
+    if (!dontResolveAlias && isNonLocalAlias(symbol, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */))
+        return resolveAlias(c, symbol);
+    return symbol;
+}
+export function getDeclarationOfAliasSymbol(symbol) {
+    for (let i = symbol.declarations.length - 1; i >= 0; i--) {
+        const d = symbol.declarations[i];
+        if (isAliasSymbolDeclaration(d))
+            return d;
+    }
+    return undefined;
+}
+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 */:
+            return true;
+        case 274 /* SyntaxKind.ImportClause */:
+            return getName(node) !== undefined;
+        case 278 /* SyntaxKind.ExportAssignment */: {
+            const e = getExpression(node);
+            return e !== undefined && isEntityNameExpressionNode(e);
+        }
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return isJSAliasDeclaration(node);
+    }
+    return false;
+}
+function isEntityNameExpressionNode(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const e = getExpression(node);
+        const name = getName(node);
+        return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpressionNode(e);
+    }
+    return false;
+}
+/** The alias target, unless resolving it now would be circular. */
+export function tryResolveAlias(c, symbol) {
+    if (c.symbolLinks(symbol).aliasTarget !== undefined ||
+        findResolutionCycleStartIndex(c, symbol, 9 /* TypeSystemPropertyName.AliasTarget */) < 0)
+        return resolveAlias(c, symbol);
+    return undefined;
+}
+export function resolveAlias(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    let target = links.aliasTarget;
+    if (target !== undefined)
+        return target;
+    if (!pushTypeResolution(c, symbol, 9 /* TypeSystemPropertyName.AliasTarget */))
+        return c.unknownSymbol;
+    const node = getDeclarationOfAliasSymbol(symbol);
+    let resolved = getTargetOfAliasDeclaration(c, node);
+    // A pure alias target is resolved transitively, carrying over its type-only declaration.
+    if (resolved !== undefined && isNonLocalAlias(resolved, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */))
+        resolved = resolveIndirectionAlias(c, symbol, resolved);
+    target = resolved ?? c.unknownSymbol;
+    links.aliasTarget = target;
+    if (!popTypeResolution(c)) {
+        c.error(node, 481 /* Diagnostics.Circular_definition_of_import_alias_0 */, symbolToString(c, symbol));
+        links.aliasTarget = c.unknownSymbol;
+    }
+    return links.aliasTarget;
+}
+/**
+ * The combined flags of `symbol` and every alias target; All when an alias resolves to unknown. With
+ * `excludeTypeOnlyMeanings`, the chain stops at the first alias with a type-only declaration.
+ */
+export function getSymbolFlags(c, symbol, excludeTypeOnlyMeanings = false) {
+    let flags = symbol.flags;
+    // Created for the first alias of an alias, as tsgo's zero-value set.
+    let seen = undefined;
+    while ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+        if (excludeTypeOnlyMeanings && getTypeOnlyAliasDeclaration(c, symbol) !== undefined)
+            break;
+        const target = getExportSymbolOfValueSymbolIfExported(c, resolveAlias(c, symbol));
+        if (target === c.unknownSymbol)
+            return 1073741823 /* SymbolFlags.All */;
+        if ((target.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            if (target === symbol || (seen !== undefined && seen.has(target)))
+                break;
+            if (seen === undefined)
+                seen = new Set();
+            seen.add(symbol);
+            seen.add(target);
+        }
+        flags |= target.flags;
+        symbol = target;
+    }
+    return flags;
+}
+// ---- Members and exports
+export function getExportsOfSymbol(c, symbol) {
+    if ((symbol.flags & 6256 /* SymbolFlags.LateBindingContainer */) !== 0)
+        return getResolvedMembersOrExports(c, symbol, true);
+    if ((symbol.flags & 1536 /* SymbolFlags.Module */) !== 0)
+        return getExportsOfModule(c, symbol);
+    return symbol.exports ?? emptySymbolTable;
+}
+export const emptySymbolTable = new Map();
+export function getExportsOfModule(c, moduleSymbol) {
+    // Late-bound members share the cache.
+    if ((moduleSymbol.flags & 6256 /* SymbolFlags.LateBindingContainer */) !== 0)
+        return getResolvedMembersOrExports(c, moduleSymbol, true);
+    const links = c.symbolLinks(moduleSymbol);
+    let exports = links.resolvedExports;
+    if (exports === undefined) {
+        exports = getExportsOfModuleWorker(c, moduleSymbol);
+        links.resolvedExports = exports;
+    }
+    return exports;
+}
+export function getMembersOfSymbol(c, symbol) {
+    if ((symbol.flags & 6256 /* SymbolFlags.LateBindingContainer */) !== 0)
+        return getResolvedMembersOrExports(c, symbol, false);
+    return symbol.members ?? emptySymbolTable;
+}
+function getResolvedMembersOrExports(c, symbol, isStatic) {
+    const links = c.symbolLinks(symbol);
+    const cached = isStatic ? links.resolvedExports : links.resolvedMembers;
+    if (cached !== undefined)
+        return cached;
+    let early;
+    if (!isStatic)
+        early = symbol.members ?? emptySymbolTable;
+    else if ((symbol.flags & 1536 /* SymbolFlags.Module */) !== 0)
+        early = getExportsOfModuleWorker(c, symbol);
+    else
+        early = symbol.exports ?? emptySymbolTable;
+    if (isStatic)
+        links.resolvedExports = early;
+    else
+        links.resolvedMembers = early;
+    let late;
+    for (const decl of symbol.declarations) {
+        const members = getMembersOfDeclaration(decl);
+        if (members === undefined)
+            continue;
+        for (const member of members) {
+            if (isStatic !== hasStaticModifier(member))
+                continue;
+            if (hasLateBindableName(c, member)) {
+                if (late === undefined)
+                    late = new Map();
+                lateBindMember(c, symbol, early, late, member);
+            }
+            else if (hasLateBindableIndexSignature(c, member)) {
+                if (late === undefined)
+                    late = new Map();
+                lateBindIndexSignature(c, early, late, member);
+            }
+        }
+    }
+    // JavaScript `F[name] = …` assignments with late-bindable names.
+    const assignments = isStatic ? symbol.exports?.get("\uFFFEassignment" /* InternalSymbolName.AssignmentDeclaration */) : undefined;
+    if (assignments !== undefined)
+        for (const member of assignments.declarations)
+            if (hasLateBindableName(c, member)) {
+                if (late === undefined)
+                    late = new Map();
+                lateBindMember(c, symbol, early, late, member);
+            }
+    const result = late === undefined ? early : combineSymbolTables(c, early, late);
+    if (isStatic)
+        links.resolvedExports = result;
+    else
+        links.resolvedMembers = result;
+    return result;
+}
+function getMembersOfDeclaration(decl) {
+    switch (decl.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 188 /* SyntaxKind.TypeLiteral */:
+            return getMemberNodes(decl)?.nodes;
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            return getProperties(decl).nodes;
+    }
+    return undefined;
+}
+export function combineSymbolTables(c, first, second) {
+    if (first.size === 0)
+        return second;
+    if (second.size === 0)
+        return first;
+    const combined = new Map();
+    mergeSymbolTable(c, combined, first, false, undefined);
+    mergeSymbolTable(c, combined, second, false, undefined);
+    return combined;
+}
+/** Binds a member with a computed name whose type is a literal or unique symbol under that name. */
+function lateBindMember(c, parent, early, late, decl) {
+    const cached = c.resolvedSymbols.get(decl.id);
+    if (cached !== undefined)
+        return cached;
+    // 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 */
+        ? checkExpressionCached(c, declName.argumentExpression)
+        : checkComputedPropertyName(c, declName);
+    if (isTypeUsableAsPropertyName(type)) {
+        const memberName = getPropertyNameFromType(type);
+        const symbolFlags = getSymbol(decl).flags;
+        let lateSymbol = late.get(memberName);
+        if (lateSymbol === undefined) {
+            lateSymbol = c.newSymbolWithCheckFlags(0 /* SymbolFlags.None */, memberName, 4096 /* CheckFlags.Late */);
+            late.set(memberName, lateSymbol);
+        }
+        const earlySymbol = early.get(memberName);
+        if ((lateSymbol.flags & getExcludedSymbolFlags(symbolFlags)) !== 0) {
+            const declarations = earlySymbol !== undefined ? earlySymbol.declarations.concat(lateSymbol.declarations) : lateSymbol.declarations;
+            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.symbolNameTypes.set(getSymbolId(lateSymbol), type);
+        addDeclarationToLateBoundSymbol(c, lateSymbol, decl, symbolFlags);
+        if (lateSymbol.parent === undefined)
+            lateSymbol.parent = parent;
+        c.resolvedSymbols.set(decl.id, lateSymbol);
+    }
+    return c.resolvedSymbols.get(decl.id);
+}
+/** Adds a member whose computed name has a non-literal key type to the index symbol. */
+function lateBindIndexSignature(c, early, late, decl) {
+    let indexSymbol = late.get("\uFFFEindex" /* InternalSymbolName.Index */);
+    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 */);
+        else {
+            indexSymbol = cloneSymbol(c, earlyIndex);
+            indexSymbol.checkFlags |= 4096 /* CheckFlags.Late */;
+        }
+        late.set("\uFFFEindex" /* InternalSymbolName.Index */, indexSymbol);
+    }
+    // Unlike late-bound members, `decl` gets no late symbol: the index symbol isn't one property.
+    if (indexSymbol.declarations.length === 0 || (getSymbol(decl).flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0)
+        addDeclaration(indexSymbol, decl);
+}
+function addDeclarationToLateBoundSymbol(c, symbol, member, symbolFlags) {
+    const memberSymbol = getSymbol(member);
+    c.symbolLinks(memberSymbol).lateSymbol = symbol;
+    if (symbol.declarations.length === 0 || (memberSymbol.flags & 536870912 /* SymbolFlags.ReplaceableByMethod */) === 0) {
+        symbol.flags |= symbolFlags;
+        addDeclaration(symbol, member);
+    }
+    if ((symbolFlags & 111551 /* SymbolFlags.Value */) !== 0)
+        setValueDeclaration(symbol, member);
+}
+export function isReservedMemberName(name) {
+    if (name.length < 2 || name.charCodeAt(0) !== 0xfffe)
+        return false;
+    const second = name.charCodeAt(1);
+    return second !== 0x40 && second !== 0x23;
+}
+/** Whether `symbol` has a value meaning; one reached through a type-only alias doesn't count. */
+export function symbolIsValue(c, symbol) {
+    return ((symbol.flags & 111551 /* SymbolFlags.Value */) !== 0 ||
+        ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && (getSymbolFlags(c, symbol, true) & 111551 /* SymbolFlags.Value */) !== 0));
+}
+function isDeclarationContainedBy(symbol, container) {
+    const declaration = symbol.valueDeclaration;
+    if (declaration !== undefined)
+        for (const d of container.declarations)
+            if (declaration.pos >= d.pos && declaration.end <= d.end)
+                return true;
+    return false;
+}
+/** Value members other than signatures and index signatures, declared ones first, each part ordered by declaration. */
+export function getNamedMembers(c, members, container) {
+    if (members === undefined || members.size === 0)
+        return [];
+    const isClassOrInterface = container !== undefined && (container.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) !== 0;
+    const contained = [];
+    const rest = [];
+    for (const [id, symbol] of members) {
+        if (isReservedMemberName(id) || !symbolIsValue(c, symbol))
+            continue;
+        if (isClassOrInterface && isDeclarationContainedBy(symbol, container))
+            contained.push(symbol);
+        else
+            rest.push(symbol);
+    }
+    sortSymbols(c, contained);
+    sortSymbols(c, rest);
+    return contained.length === 0 ? rest : contained.concat(rest);
+}
+/** Sorts symbols by declaration order; members are usually in that order already. */
+function sortSymbols(c, symbols) {
+    for (let i = 1; i < symbols.length; i++)
+        if (compareSymbols(c, symbols[i - 1], symbols[i]) > 0) {
+            symbols.sort((a, b) => compareSymbols(c, a, b));
+            return;
+        }
+}
+// ---- Entity names
+export function getFirstIdentifier(node) {
+    let current = node;
+    for (;;) {
+        if (current.kind === 167 /* SyntaxKind.QualifiedName */)
+            current = current.left;
+        else if (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+            current = getExpression(current);
+        else
+            return current;
+    }
+}
+export function resolveEntityName(c, name, meaning, ignoreErrors, dontResolveAlias, location) {
+    if (nodeIsMissing(name))
+        return undefined;
+    let symbol;
+    if (name.kind === 79 /* SyntaxKind.Identifier */) {
+        const message = ignoreErrors
+            ? undefined
+            : meaning === 1920 /* SymbolFlags.Namespace */ || (name.flags & 16 /* NodeFlags.Synthesized */) !== 0
+                ? 663 /* Diagnostics.Cannot_find_namespace_0 */
+                : getCannotFindNameDiagnosticForName(c, getFirstIdentifier(name));
+        const resolveLocation = location ?? name;
+        const text = getText(name);
+        if (meaning === 1920 /* SymbolFlags.Namespace */) {
+            const found = resolveName(c, resolveLocation, text, meaning, undefined, true, false);
+            symbol = found !== undefined ? getMergedSymbol(c, found) : undefined;
+            if (symbol === undefined) {
+                // Typedefs exported from CommonJS are stored on the module symbol, the parent of its `export=`. The
+                // lookup also marks an alias of the name as referenced.
+                const alias = resolveName(c, resolveLocation, text, 2097152 /* SymbolFlags.Alias */, undefined, true, false);
+                if (alias !== undefined && getMergedSymbol(c, alias).name === "export=" /* InternalSymbolName.ExportEquals */)
+                    symbol = getMergedSymbol(c, alias).parent;
+            }
+            if (symbol === undefined && message !== undefined)
+                resolveName(c, resolveLocation, text, meaning, message, true, false);
+        }
+        else {
+            const found = resolveName(c, resolveLocation, text, meaning, message, true, false);
+            symbol = found !== undefined ? getMergedSymbol(c, found) : undefined;
+        }
+    }
+    else if (name.kind === 167 /* SyntaxKind.QualifiedName */) {
+        const qualified = name;
+        symbol = resolveQualifiedName(c, name, qualified.left, qualified.right, meaning, ignoreErrors, location);
+    }
+    else if (name.kind === 212 /* 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 */ &&
+            ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 ||
+                (name.parent !== undefined && name.parent.kind === 278 /* 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)
+            symbol = resolveAlias(c, symbol);
+    }
+    return symbol;
+}
+function resolveQualifiedName(c, name, left, right, meaning, ignoreErrors, location) {
+    const namespace = resolveEntityName(c, left, 1920 /* SymbolFlags.Namespace */, ignoreErrors, false, location);
+    if (namespace === undefined || nodeIsMissing(right))
+        return undefined;
+    if (namespace === c.unknownSymbol)
+        return namespace;
+    const text = getText(right);
+    let found = getSymbolOfMeaning(c, getExportsOfSymbol(c, namespace), text, meaning);
+    // A namespace merged with a re-export resolves further.
+    if (found === undefined && (namespace.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        found = getSymbolOfMeaning(c, getExportsOfSymbol(c, resolveAlias(c, namespace)), text, meaning);
+    if (found !== undefined)
+        return getMergedSymbol(c, found);
+    if (ignoreErrors)
+        return undefined;
+    const namespaceName = getFullyQualifiedName(c, namespace);
+    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));
+        return undefined;
+    }
+    let containingQualifiedName;
+    if (name.kind === 167 /* SyntaxKind.QualifiedName */) {
+        containingQualifiedName = name;
+        while (containingQualifiedName.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+            containingQualifiedName = containingQualifiedName.parent;
+    }
+    if (
+    // Not while the checker is being created, before global types are known.
+    c.hasGlobalObjectType &&
+        (meaning & 788968 /* SymbolFlags.Type */) !== 0 &&
+        containingQualifiedName !== undefined &&
+        containingQualifiedName.parent.kind !== 222 /* 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));
+        return undefined;
+    }
+    if ((meaning & 1920 /* SymbolFlags.Namespace */) !== 0 &&
+        name.parent !== undefined &&
+        name.parent.kind === 167 /* 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);
+            return undefined;
+        }
+    }
+    c.error(right, 826 /* Diagnostics.Namespace_0_has_no_exported_member_1 */, namespaceName, declarationName);
+    return undefined;
+}
+/** The value a qualified name denotes as a property access, if any. */
+function tryGetQualifiedNameAsValue(c, node) {
+    const id = getFirstIdentifier(node);
+    let symbol = resolveName(c, id, getText(id), 111551 /* SymbolFlags.Value */, undefined, true, false);
+    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);
+        if (symbol === undefined)
+            return undefined;
+        current = current.parent;
+    }
+    return symbol;
+}
+/**
+ * `symbol` qualified by its parents. The outermost one is written as seen from `containingLocation`
+ * if given, so that a module is named by a specifier the containing file could import it with.
+ */
+export function getFullyQualifiedName(c, symbol, containingLocation) {
+    return symbol.parent !== undefined
+        ? getFullyQualifiedName(c, symbol.parent, containingLocation) + '.' + symbolToString(c, symbol)
+        : symbolToString(c, symbol, containingLocation, 4 /* NodeBuilderInternalFlags.DoNotIncludeSymbolChain */);
+}
+export function getCannotFindNameDiagnosticForName(c, node) {
+    const wildcard = c.compilerOptions.types !== undefined && c.compilerOptions.types.includes('*');
+    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 */;
+        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 */;
+        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 */;
+        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 */;
+        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 */;
+        // tsgo lists `ast.Symbol` here rather than `Symbol`.
+        case 'Map':
+        case 'Set':
+        case 'Promise':
+        case 'WeakMap':
+        case 'WeakSet':
+        case 'Iterator':
+        case 'AsyncIterator':
+        case 'SharedArrayBuffer':
+        case 'Atomics':
+        case 'AsyncIterable':
+        case 'AsyncIterableIterator':
+        case 'AsyncGenerator':
+        case 'AsyncGeneratorFunction':
+        case 'BigInt':
+        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 */;
+        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 */;
+            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 */;
+}
+/**
+ * Pushes a resolution of `propertyName` on `target`. When the same resolution is already on the
+ * stack with no resolved entries above it, marks the cycle and returns false.
+ */
+export function pushTypeResolution(c, target, propertyName) {
+    const start = findResolutionCycleStartIndex(c, target, propertyName);
+    if (start >= 0) {
+        c.resolutionCycleCount++;
+        for (let i = start; i < c.resolutionDepth; i++)
+            c.resolutionResults[i] = false;
+        return false;
+    }
+    const depth = c.resolutionDepth;
+    if (depth < c.resolutionTargets.length) {
+        c.resolutionTargets[depth] = target;
+        c.resolutionPropertyNames[depth] = propertyName;
+        c.resolutionResults[depth] = true;
+    }
+    else {
+        c.resolutionTargets.push(target);
+        c.resolutionPropertyNames.push(propertyName);
+        c.resolutionResults.push(true);
+    }
+    c.resolutionDepth = depth + 1;
+    return true;
+}
+/** Pops the last resolution; false if it was part of a cycle. */
+export function popTypeResolution(c) {
+    const depth = c.resolutionDepth - 1;
+    c.resolutionDepth = depth;
+    return c.resolutionResults[depth];
+}
+export function findResolutionCycleStartIndex(c, target, propertyName) {
+    for (let i = c.resolutionDepth - 1; i >= c.resolutionStart; i--) {
+        if (resolutionHasProperty(c, c.resolutionTargets[i], c.resolutionPropertyNames[i]))
+            return -1;
+        if (c.resolutionTargets[i] === target && c.resolutionPropertyNames[i] === propertyName)
+            return i;
+    }
+    return -1;
+}
+function resolutionHasProperty(c, target, propertyName) {
+    switch (propertyName) {
+        case 0 /* TypeSystemPropertyName.Type */:
+            return c.symbolTypes.get(getSymbolId(target)) !== undefined;
+        case 2 /* TypeSystemPropertyName.DeclaredType */:
+            return c.symbolLinks(target).declaredType !== undefined;
+        case 5 /* TypeSystemPropertyName.ResolvedTypeArguments */:
+            return (typeReferenceOf(target).resolvedTypeArguments !== undefined ||
+                sideOf(c, typeReferenceOf(target)).resolvedTypeArguments !== undefined);
+        case 6 /* TypeSystemPropertyName.ResolvedBaseTypes */:
+            return sideOf(c, interfaceTypeOf(target)).baseTypesResolved;
+        case 1 /* TypeSystemPropertyName.ResolvedBaseConstructorType */:
+            return sideOf(c, interfaceTypeOf(target)).resolvedBaseConstructorType !== undefined;
+        case 3 /* TypeSystemPropertyName.ResolvedReturnType */:
+            return (target.resolvedReturnType !== undefined ||
+                signatureSideOf(c, target).resolvedReturnType !== undefined);
+        case 4 /* TypeSystemPropertyName.ResolvedBaseConstraint */:
+            return (target.resolvedBaseConstraint !== undefined ||
+                sideOf(c, target).resolvedBaseConstraint !== undefined);
+        case 8 /* TypeSystemPropertyName.InitializerIsUndefined */:
+            return ((c.existingNodeLinks(target)?.flags ?? 0) & (1 << 25)) !== 0;
+        case 7 /* TypeSystemPropertyName.WriteType */:
+            return c.symbolLinks(target).writeType !== undefined;
+        case 9 /* TypeSystemPropertyName.AliasTarget */:
+            return c.symbolLinks(target).aliasTarget !== undefined;
+    }
+    return false;
+}
+function typeReferenceOf(t) {
+    return t;
+}
+function interfaceTypeOf(t) {
+    return t;
+}
+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));
+            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));
+    }
+    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));
+    }
+    // Circularities could also result from parameters in function expressions that end up having themselves as
+    // contextual types. Those are reported elsewhere.
+    return c.anyType;
+}
+export { getTypeOfSymbol, getSourceFileOfNode };