tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,2141 @@
+// External modules: resolving module specifiers, alias targets of imports and exports, module
+// exports, import types, dynamic imports, and the semantic checks of import and export declarations.
+//
+// Module-not-found errors are reported on every resolution with an error node, as tsgo does: an
+// unresolved `import { a } from "m"` reports once for the declaration and again for each use of `a`.
+import { checkCollisionsForDeclarationName } from './checker-generated-code.js';
+import { checkDeprecatedImportSpecifier } from './checker-deprecation.js';
+import { getExpression, getInitializer, getIsTypeOnly, getLocals, getModuleSpecifier, getName, getPropertyName, getSymbol, getText, getType, } from './ast.js';
+import { getExternalModuleName, isAmbientModule, isImportCall, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLiteralImportTypeNode, isRequireCall, isStringLiteralLike, isTypeOnly, nodeIsMissing, } from './ast-utilities.js';
+import { declarationNameToString, getDeclarationOfKind, getModifierFlags, isAccessExpression, getRootDeclaration, getSourceTextOfNode, getThisContainer, getSourceFileOfNode, hasSyntacticModifier, isGlobalSourceFile, isJsonSourceFile, isModuleAugmentationExternal, isPartOfTypeQuery, isVariableDeclarationInitializedToRequire, moduleExportNameIsDefault, } from './binder-utilities.js';
+import { chainDiagnostic, RepopulateInfo, } from './diagnostics.js';
+import { JsxEmit, ModuleKind, ModuleResolutionKind, getAllowImportingTsExtensions, getEmitModuleKind, getModuleResolutionKind, getResolveJsonModule, } from './options.js';
+import { getResolutionDiagnostic, getTypesPackageName, mangleScopedPackageName, } from './module-resolution-types.js';
+import { getResolutionModeOverride, moduleKindName } from './program-utilities.js';
+import { hasExtension } from './vfs-match.js';
+import { isNodeCoreModule } from './parser.js';
+import { combinePaths, extensionIsTs, fileExtensionIsOneOf, getDeclarationFileExtension, getDirectoryPath, getNormalizedAbsolutePath, isDeclarationFileName, isExternalModuleNameRelative, pathIsRelative, removeExtension, supportedTSExtensionsFlat, tryExtractTSExtension, tryGetExtensionFromPath, } from './path.js';
+import { getSymbolId } from './symbol.js';
+import { isExpressionNode } from './transformers/alias-references.js';
+import { createDiagnosticForNode } from './checker.js';
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { createAnonymousType, getRegularTypeOfLiteralType, getStringLiteralType, isErrorType, } from './checker-type-factory.js';
+import { getFullyQualifiedName, getMergedSymbol, getSpellingSuggestionForName, getSymbolFlags, getSymbolOfDeclaration, getSymbolOfMeaning, getDeclarationOfAliasSymbol, getExportSymbolOfValueSymbolIfExported, getExportsOfModule, getExportsOfSymbol, resolveAlias, resolveEntityName, resolveName, resolveSymbol, resolveSymbolEx, isNonLocalAlias, getCachedGlobalType, } from './checker-symbols.js';
+import { getTypeOfSymbol, getNullableType } from './checker-symbol-types.js';
+import { getPropertyOfType, getPropertyOfTypeEx, getSignaturesOfStructuredType, resolveStructuredTypeMembers, } from './checker-members.js';
+import { getTypeFromTypeNode, getTypeReferenceType } from './checker-type-nodes.js';
+import { checkExpression, checkExpressionCached, getResolvedSymbol } from './checker-expressions.js';
+import { isTypeAssignableTo, checkTypeAssignableTo } from './relations.js';
+import { getSpreadType } from './checker-object-literals.js';
+import { checkExternalModuleExports, shouldCheckErasableSyntax } from './checker-declarations.js';
+import { checkTypeNameIsReserved } from './checker-classes.js';
+import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
+import { isValidSpreadType } from './checker-destructuring.js';
+import { createPromiseType } from './checker-iteration.js';
+import { symbolToString, typeToString } from './type-printer.js';
+import { checkTypeAssignableToAndOptionallyElaborate } from './checker-expressions.js';
+import { grammarErrorOnNode } from './checker-operators.js';
+// ---- Resolution
+/** The module symbol `moduleReference` names, reporting it when it isn't found unless `ignoreErrors`. */
+export function resolveExternalModuleName(c, location, moduleReference, ignoreErrors) {
+    return resolveExternalModuleNameWorker(c, location, moduleReference, ignoreErrors ? undefined : getCannotResolveModuleNameError(c, moduleReference), ignoreErrors, false);
+}
+/** Node core modules suggest installing `@types/node`. */
+function getCannotResolveModuleNameError(c, moduleReference) {
+    if (moduleReference !== undefined &&
+        moduleReference.kind === 10 /* SyntaxKind.StringLiteral */ &&
+        isNodeCoreModule(getText(moduleReference))) {
+        const types = c.compilerOptions.types;
+        return types !== undefined && types.includes('*')
+            ? 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 */;
+    }
+    return 485 /* Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations */;
+}
+export function resolveExternalModuleNameWorker(c, location, moduleReference, moduleNotFoundError, ignoreErrors, isForAugmentation) {
+    if (moduleReference === undefined || !isStringLiteralLike(moduleReference))
+        return undefined;
+    return resolveExternalModule(c, location, getText(moduleReference), moduleNotFoundError, ignoreErrors ? undefined : moduleReference, isForAugmentation);
+}
+export function resolveExternalModule(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+    if (errorNode !== undefined && moduleReference.startsWith('@types/'))
+        c.error(errorNode, 1302 /* Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1 */, moduleReference.substring(7), moduleReference);
+    const ambient = tryFindAmbientModule(c, moduleReference, true);
+    if (ambient !== undefined)
+        return ambient;
+    const importingFile = getSourceFileOfNode(location);
+    const contextSpecifier = getContextSpecifier(location);
+    const mode = contextSpecifier !== undefined && isStringLiteralLike(contextSpecifier)
+        ? c.host.getModeForUsageLocation(importingFile, contextSpecifier)
+        : c.host.getDefaultResolutionModeForFile(importingFile);
+    const resolved = c.host.getResolvedModule(importingFile, moduleReference, mode);
+    const isResolved = resolved !== undefined && resolved.resolvedFileName !== '';
+    const resolutionDiagnostic = errorNode !== undefined && isResolved
+        ? getResolutionDiagnostic(c.compilerOptions, resolved, importingFile.isDeclarationFile)
+        : undefined;
+    const file = isResolved &&
+        (resolutionDiagnostic === undefined ||
+            resolutionDiagnostic === 1307 /* Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set */)
+        ? c.host.getSourceFileForResolvedModule(resolved.resolvedFileName)
+        : undefined;
+    if (file !== undefined) {
+        if (errorNode !== undefined) {
+            // A resolution error is reported even though the file was found.
+            if (resolutionDiagnostic !== undefined)
+                c.error(errorNode, resolutionDiagnostic, moduleReference, resolved.resolvedFileName);
+            checkResolvedModuleExtension(c, location, moduleReference, resolved, importingFile, mode, errorNode);
+        }
+        if (file.symbol !== undefined) {
+            if (errorNode !== undefined) {
+                if (resolved.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolved.extension))
+                    errorOnImplicitAnyModule(c, false, errorNode, mode, resolved, moduleReference);
+                checkSyncImportOfESModule(c, location, moduleReference, importingFile, file, errorNode);
+            }
+            return getMergedSymbol(c, file.symbol);
+        }
+        if (errorNode !== undefined && moduleNotFoundError !== undefined && !isSideEffectImport(errorNode))
+            c.error(errorNode, 484 /* Diagnostics.File_0_is_not_a_module */, resolved.resolvedFileName);
+        return undefined;
+    }
+    // The pattern with the longest prefix wins.
+    let best;
+    let bestPrefix = -1;
+    for (const pattern of c.patternAmbientModules) {
+        if (pattern.matches(moduleReference) && pattern.starIndex > bestPrefix) {
+            bestPrefix = pattern.starIndex;
+            best = pattern.symbol;
+        }
+    }
+    if (best !== undefined)
+        return getMergedSymbol(c, c.patternAmbientModuleAugmentations.get(moduleReference) ?? best);
+    if (errorNode === undefined)
+        return undefined;
+    // A module that resolved to JavaScript is untyped.
+    if ((isResolved && !resolutionExtensionIsTSOrJson(resolved.extension) && resolutionDiagnostic === undefined) ||
+        resolutionDiagnostic === 1688 /* Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type */) {
+        if (isForAugmentation)
+            c.error(errorNode, 799 /* Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented */, moduleReference, resolved.resolvedFileName);
+        else
+            errorOnImplicitAnyModule(c, c.noImplicitAny && moduleNotFoundError !== undefined, errorNode, mode, resolved, moduleReference);
+        return undefined;
+    }
+    if (moduleNotFoundError === undefined)
+        return undefined;
+    if (isResolved) {
+        // A source file of a referenced project whose output hasn't been built.
+        const outputDts = c.host.getProjectReferenceOutputDts(resolved.resolvedFileName);
+        if (outputDts !== '') {
+            c.error(errorNode, 1444 /* Diagnostics.Output_file_0_has_not_been_built_from_source_file_1 */, outputDts, resolved.resolvedFileName);
+            return undefined;
+        }
+    }
+    if (resolutionDiagnostic !== undefined) {
+        c.error(errorNode, resolutionDiagnostic, moduleReference, resolved.resolvedFileName);
+        return undefined;
+    }
+    const resolution = getModuleResolutionKind(c.compilerOptions);
+    if (!getResolveJsonModule(c.compilerOptions) && moduleReference.endsWith('.json'))
+        c.error(errorNode, 864 /* Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension */, moduleReference);
+    else if (mode === ModuleKind.ESNext &&
+        (resolution === ModuleResolutionKind.Node16 || resolution === ModuleResolutionKind.NodeNext) &&
+        pathIsRelative(moduleReference) &&
+        !hasExtension(moduleReference)) {
+        const absolute = getNormalizedAbsolutePath(moduleReference, getDirectoryPath(importingFile.fileName));
+        const extension = getSuggestedImportExtension(c, absolute);
+        if (extension !== '')
+            c.error(errorNode, 957 /* Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0 */, moduleReference + extension);
+        else
+            c.error(errorNode, 956 /* Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path */);
+    }
+    else if (resolved !== undefined && resolved.alternateResult !== '')
+        c.addDiagnostic(chainDiagnostic(createModuleNotFoundChain(c, errorNode, moduleReference, mode, moduleReference), moduleNotFoundError, moduleReference));
+    else
+        c.error(errorNode, moduleNotFoundError, moduleReference);
+    return undefined;
+}
+/** The module specifier that decides the resolution mode of a module reference at `location`. */
+function getContextSpecifier(location) {
+    const parent = location.parent;
+    if (isStringLiteralLike(location) ||
+        (parent !== undefined && parent.kind === 268 /* SyntaxKind.ModuleDeclaration */ && getName(parent) === location))
+        return location;
+    if (location.kind === 268 /* SyntaxKind.ModuleDeclaration */)
+        return getName(location);
+    if (isLiteralImportTypeNode(location))
+        return location.argument.literal;
+    const requireSpecifier = getModuleSpecifierOfBareOrAccessedRequire(location);
+    if (requireSpecifier !== undefined)
+        return requireSpecifier;
+    for (let current = location; current !== undefined; current = current.parent)
+        if (isImportCall(current))
+            return current.arguments.nodes[0];
+    for (let current = location; current !== undefined; current = current.parent)
+        if (current.kind === 273 /* SyntaxKind.ImportDeclaration */ || current.kind === 346 /* SyntaxKind.JSImportDeclaration */)
+            return getModuleSpecifier(current);
+    for (let current = location; current !== undefined; current = current.parent)
+        if (current.kind === 279 /* SyntaxKind.ExportDeclaration */)
+            return getModuleSpecifier(current);
+    for (let current = location; current !== undefined; current = current.parent)
+        if (current.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */) {
+            const reference = current.moduleReference;
+            return reference.kind === 284 /* SyntaxKind.ExternalModuleReference */ ? getExpression(reference) : undefined;
+        }
+    return undefined;
+}
+/** The specifier of `const x = require("m")` or `const x = require("m").a.b` in JavaScript. */
+function getModuleSpecifierOfBareOrAccessedRequire(node) {
+    if (node.kind !== 261 /* SyntaxKind.VariableDeclaration */ || !isInJSFile(node))
+        return undefined;
+    const declaration = node;
+    let initializer = declaration.initializer;
+    if (initializer === undefined || declaration.type !== undefined)
+        return undefined;
+    if ((getModifierFlags(declaration.parent.parent) & 32 /* ModifierFlags.Export */) !== 0)
+        return undefined;
+    while (isAccessExpression(initializer))
+        initializer = getExpression(initializer);
+    return isRequireCall(initializer, true) ? initializer.arguments.nodes[0] : undefined;
+}
+function resolutionExtensionIsTSOrJson(extension) {
+    return extensionIsTs(extension) || extension === '.json';
+}
+/** Imports that name a `.ts` file need `allowImportingTsExtensions`, and declaration files can't be imported. */
+function checkResolvedModuleExtension(c, location, moduleReference, resolved, importingFile, mode, errorNode) {
+    if (!resolved.resolvedUsingTsExtension)
+        return;
+    if (isDeclarationFileName(moduleReference)) {
+        if (isInEmittableImport(location))
+            c.error(errorNode, 967 /* Diagnostics.A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_file_0_instead */, getSuggestedImportSource(c, moduleReference, tryExtractTSExtension(moduleReference), mode));
+    }
+    else if (!getAllowImportingTsExtensions(c.compilerOptions) &&
+        !isDeclarationFileName(importingFile.fileName) &&
+        isInEmittableImport(location)) {
+        let extension = tryExtractTSExtension(moduleReference);
+        // A wildcard pattern can match a `.ts` extension that doesn't end the specifier.
+        if (extension === '')
+            for (const candidate of supportedTSExtensionsFlat)
+                if (moduleReference.includes(candidate)) {
+                    extension = candidate;
+                    break;
+                }
+        c.error(errorNode, 1171 /* Diagnostics.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled */, extension);
+    }
+}
+function isInEmittableImport(location) {
+    for (let current = location; current !== undefined; current = current.parent) {
+        switch (current.kind) {
+            case 273 /* SyntaxKind.ImportDeclaration */: {
+                const clause = current.importClause;
+                if (clause !== undefined && !isTypeOnly(clause))
+                    return true;
+                break;
+            }
+            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (!getIsTypeOnly(current))
+                    return true;
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+                if (isImportCall(current))
+                    return true;
+                break;
+        }
+    }
+    return false;
+}
+/** The specifier to import instead of a declaration file: its `.js` counterpart when emitting ES modules. */
+function getSuggestedImportSource(c, moduleReference, tsExtension, mode) {
+    const withoutExtension = removeExtension(moduleReference, tsExtension);
+    const moduleKind = getEmitModuleKind(c.compilerOptions);
+    if ((ModuleKind.ES2015 <= moduleKind && moduleKind <= ModuleKind.ESNext) || mode === ModuleKind.ESNext) {
+        const preferTs = isDeclarationFileName(moduleReference) && getAllowImportingTsExtensions(c.compilerOptions);
+        if (tsExtension === '.mts' || tsExtension === '.d.mts')
+            return withoutExtension + (preferTs ? '.mts' : '.mjs');
+        if (tsExtension === '.cts' || tsExtension === '.d.cts')
+            return withoutExtension + (preferTs ? '.cts' : '.cjs');
+        return withoutExtension + (preferTs ? '.ts' : '.js');
+    }
+    return withoutExtension;
+}
+function getSuggestedImportExtension(c, extensionlessPath) {
+    const host = c.host;
+    if (host.fileExists(extensionlessPath + '.mts'))
+        return '.mjs';
+    if (host.fileExists(extensionlessPath + '.ts'))
+        return '.js';
+    if (host.fileExists(extensionlessPath + '.cts'))
+        return '.cjs';
+    if (host.fileExists(extensionlessPath + '.mjs'))
+        return '.mjs';
+    if (host.fileExists(extensionlessPath + '.js'))
+        return '.js';
+    if (host.fileExists(extensionlessPath + '.cjs'))
+        return '.cjs';
+    if (host.fileExists(extensionlessPath + '.tsx'))
+        return c.compilerOptions.jsx === JsxEmit.Preserve ? '.jsx' : '.js';
+    if (host.fileExists(extensionlessPath + '.jsx'))
+        return '.jsx';
+    if (host.fileExists(extensionlessPath + '.json'))
+        return '.json';
+    return '';
+}
+/** Under node16 and node18, a synchronous import of an ES module from a CommonJS file fails at run time. */
+function checkSyncImportOfESModule(c, location, moduleReference, importingFile, file, errorNode) {
+    const moduleKind = getEmitModuleKind(c.compilerOptions);
+    if (moduleKind !== ModuleKind.Node16 && moduleKind !== ModuleKind.Node18)
+        return;
+    const importEquals = findAncestorOfKind(location, 272 /* SyntaxKind.ImportEqualsDeclaration */);
+    const isSyncImport = (c.host.getDefaultResolutionModeForFile(importingFile) === ModuleKind.CommonJS && !isInImportCall(location)) ||
+        importEquals !== undefined;
+    if (!isSyncImport || c.host.getDefaultResolutionModeForFile(file) !== ModuleKind.ESNext)
+        return;
+    const overrideHost = findResolutionModeOverrideHost(location);
+    if (overrideHost !== undefined && hasResolutionModeOverride(overrideHost))
+        return;
+    if (importEquals !== undefined) {
+        c.error(errorNode, 386 /* Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead */, moduleReference);
+        return;
+    }
+    let details;
+    const extension = tryGetExtensionFromPath(importingFile.fileName);
+    if (extension === '.ts' || extension === '.js' || extension === '.tsx' || extension === '.jsx') {
+        details = detailsAt(errorNode, modeMismatchDetails(c.host, importingFile));
+        details.repopulateInfo = new RepopulateInfo(1 /* RepopulateKind.ModeMismatch */);
+    }
+    let message = 394 /* Diagnostics.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead */;
+    if (overrideHost !== undefined && overrideHost.kind === 273 /* SyntaxKind.ImportDeclaration */) {
+        const clause = overrideHost.importClause;
+        if (clause !== undefined && isTypeOnly(clause))
+            message =
+                456 /* Diagnostics.Type_only_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute */;
+    }
+    else if (overrideHost !== undefined && overrideHost.kind === 206 /* SyntaxKind.ImportType */)
+        message =
+            457 /* Diagnostics.Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute */;
+    c.addDiagnostic(details !== undefined
+        ? chainDiagnostic(details, message, moduleReference)
+        : createDiagnosticForNode(errorNode, message, [moduleReference]));
+}
+function findAncestorOfKind(node, kind) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (current.kind === kind)
+            return current;
+    return undefined;
+}
+function isInImportCall(node) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (isImportCall(current))
+            return true;
+    return false;
+}
+function findResolutionModeOverrideHost(node) {
+    for (let current = node; current !== undefined; current = current.parent)
+        switch (current.kind) {
+            case 206 /* SyntaxKind.ImportType */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+                return current;
+        }
+    return undefined;
+}
+function hasResolutionModeOverride(node) {
+    let attributes;
+    if (node.kind === 206 /* SyntaxKind.ImportType */)
+        attributes = node.attributes;
+    else if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+        attributes = node.attributes;
+    else
+        attributes = node.attributes;
+    return attributes !== undefined && getResolutionModeOverride(attributes) !== ModuleKind.None;
+}
+/** A message with its arguments, the elaboration of a diagnostic before it has a location. */
+export class DiagnosticDetails {
+    message;
+    args;
+    constructor(message, args) {
+        this.message = message;
+        this.args = args;
+    }
+}
+function detailsAt(node, details) {
+    return createDiagnosticForNode(node, details.message, details.args);
+}
+/**
+ * How to make the CommonJS file `file` an ES module, elaborating an error about importing one from
+ * it; also what an incremental build recomputes for a stored diagnostic (`RepopulateKind.ModeMismatch`).
+ */
+export function modeMismatchDetails(host, file) {
+    const extension = tryGetExtensionFromPath(file.fileName);
+    const targetExtension = extension === '.ts' ? '.mts' : extension === '.js' ? '.mjs' : '';
+    const metadata = host.getSourceFileMetadata(file);
+    const packageJsonDirectory = metadata !== undefined ? metadata.packageJsonDirectory : '';
+    if (packageJsonDirectory !== '' && metadata.packageJsonType === '') {
+        const packageJson = combinePaths(packageJsonDirectory, 'package.json');
+        return targetExtension !== ''
+            ? new DiagnosticDetails(396 /* Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1 */, [targetExtension, packageJson])
+            : new DiagnosticDetails(397 /* Diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0 */, [packageJson]);
+    }
+    return targetExtension !== ''
+        ? new DiagnosticDetails(395 /* Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module */, [targetExtension])
+        : new DiagnosticDetails(398 /* Diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module */, []);
+}
+/** Reports a module without types: an error under `noImplicitAny`, otherwise a suggestion. */
+function errorOnImplicitAnyModule(c, isError, errorNode, mode, resolved, moduleReference) {
+    if (isSideEffectImport(errorNode))
+        return;
+    const packageName = resolved.packageId !== undefined ? resolved.packageId.name : '';
+    const chain = !isExternalModuleNameRelative(moduleReference) && packageName !== ''
+        ? createModuleNotFoundChain(c, errorNode, moduleReference, mode, packageName)
+        : undefined;
+    const message = 1688 /* Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type */;
+    c.addErrorOrSuggestion(isError, chain !== undefined
+        ? chainDiagnostic(chain, message, moduleReference, resolved.resolvedFileName)
+        : createDiagnosticForNode(errorNode, message, [moduleReference, resolved.resolvedFileName]));
+}
+/** Where types for a module might come from, elaborating an error about a module without them. */
+function createModuleNotFoundChain(c, errorNode, moduleReference, mode, packageName) {
+    const file = getSourceFileOfNode(errorNode);
+    const result = detailsAt(errorNode, moduleNotFoundDetails(c.host, file, moduleReference, mode, packageName));
+    result.repopulateInfo = new RepopulateInfo(2 /* RepopulateKind.ModuleNotFound */, moduleReference, mode, packageName === moduleReference ? '' : packageName);
+    return result;
+}
+/**
+ * Where types for `moduleReference`, imported by `file`, might come from; also what an incremental
+ * build recomputes for a stored diagnostic (`RepopulateKind.ModuleNotFound`).
+ */
+export function moduleNotFoundDetails(host, file, moduleReference, mode, packageNameIn) {
+    let packageName = packageNameIn;
+    const resolved = host.getResolvedModule(file, moduleReference, mode);
+    if (resolved !== undefined && resolved.alternateResult !== '') {
+        if (resolved.alternateResult.includes('/node_modules/@types/'))
+            packageName = '@types/' + mangleScopedPackageName(packageName);
+        return new DiagnosticDetails(1427 /* Diagnostics.There_are_types_at_0_but_this_result_could_not_be_resolved_when_respecting_package_json_exports_The_1_library_may_need_to_update_its_package_json_or_typings */, [resolved.alternateResult, packageName]);
+    }
+    const packages = host.getPackagesMap();
+    if (packages.has(getTypesPackageName(packageName)))
+        return new DiagnosticDetails(1711 /* Diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1 */, [packageName, mangleScopedPackageName(packageName)]);
+    if (packages.get(packageName) === true)
+        return new DiagnosticDetails(1729 /* Diagnostics.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1 */, [packageName, moduleReference]);
+    return new DiagnosticDetails(1706 /* Diagnostics.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0 */, [moduleReference, mangleScopedPackageName(packageName)]);
+}
+function isSideEffectImport(node) {
+    let current = node;
+    while (current !== undefined && current.kind !== 273 /* SyntaxKind.ImportDeclaration */)
+        current = current.parent;
+    return current !== undefined && current.importClause === undefined;
+}
+export function tryFindAmbientModule(c, moduleName, withAugmentations) {
+    if (isExternalModuleNameRelative(moduleName))
+        return undefined;
+    const symbol = getSymbolOfMeaning(c, c.globals, '"' + moduleName + '"', 512 /* SymbolFlags.ValueModule */);
+    return symbol !== undefined && withAugmentations ? getMergedSymbol(c, symbol) : symbol;
+}
+/** The `export =` target of a module, or the module itself. */
+export function resolveExternalModuleSymbol(c, moduleSymbol, dontResolveAlias) {
+    if (moduleSymbol === undefined)
+        return undefined;
+    const exportEquals = moduleSymbol.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+    if (exportEquals === undefined)
+        return moduleSymbol;
+    return getMergedSymbol(c, resolveSymbolEx(c, exportEquals, dontResolveAlias));
+}
+/** The module as a namespace: removes call and construct signatures, or wraps it with a synthetic default. */
+export function resolveESModuleSymbol(c, moduleSymbol, node, moduleSpecifier) {
+    let symbol = resolveExternalModuleSymbol(c, moduleSymbol, true);
+    if (symbol !== undefined && isNonLocalAlias(symbol, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) {
+        const source = getSymbolOfDeclaration(c, node);
+        symbol = getMergedSymbol(c, source !== undefined ? resolveIndirectionAlias(c, source, symbol) : resolveAlias(c, symbol));
+    }
+    if (symbol === undefined || moduleSymbol === undefined)
+        return symbol;
+    const referenceParent = moduleSpecifier.parent;
+    const namespaceImport = referenceParent.kind === 273 /* SyntaxKind.ImportDeclaration */ ? getNamespaceImport(referenceParent) : undefined;
+    if (namespaceImport === undefined && !isImportCall(referenceParent))
+        return symbol;
+    const reference = isImportCall(referenceParent)
+        ? referenceParent.arguments.nodes[0]
+        : getModuleSpecifier(referenceParent);
+    const type = getTypeOfSymbol(c, symbol);
+    const defaultOnlyType = getTypeWithSyntheticDefaultOnly(c, type, symbol, moduleSymbol, reference);
+    if (defaultOnlyType !== undefined)
+        return cloneTypeAsModuleType(c, symbol, defaultOnlyType);
+    if (hasSignatures(c, type) || getPropertyOfTypeEx(c, type, "default" /* InternalSymbolName.Default */, true, false) !== undefined) {
+        const moduleType = (type.flags & 403701760 /* TypeFlags.StructuredType */) !== 0
+            ? getTypeWithSyntheticDefaultImportType(c, type, symbol, moduleSymbol, reference)
+            : createDefaultPropertyWrapperForModule(c, symbol, symbol.parent, undefined);
+        return cloneTypeAsModuleType(c, symbol, moduleType);
+    }
+    return symbol;
+}
+function getNamespaceImport(declaration) {
+    const clause = declaration.importClause;
+    const bindings = clause?.namedBindings;
+    return bindings !== undefined && bindings.kind === 275 /* SyntaxKind.NamespaceImport */ ? bindings : undefined;
+}
+function hasSignatures(c, type) {
+    return (getSignaturesOfStructuredType(c, type, 0 /* SignatureKind.Call */).length > 0 ||
+        getSignaturesOfStructuredType(c, type, 1 /* SignatureKind.Construct */).length > 0);
+}
+/**
+ * Whether the module `usage` names is a JSON module imported into an ES module under `--module node16` to
+ * `nodenext`, which Node.js gives only a default export.
+ */
+function isOnlyImportableAsDefault(c, usage, resolvedModule) {
+    const moduleKind = getEmitModuleKind(c.compilerOptions);
+    if (moduleKind < ModuleKind.Node16 || moduleKind > ModuleKind.NodeNext)
+        return false;
+    if (getEmitSyntaxForModuleSpecifierExpression(c, usage) !== ModuleKind.ESNext)
+        return false;
+    const moduleSymbol = resolvedModule ?? resolveExternalModuleName(c, usage, usage, true);
+    const targetFile = moduleSymbol !== undefined ? getSourceFileOfModuleSymbol(moduleSymbol) : undefined;
+    return (targetFile !== undefined &&
+        (isJsonSourceFile(targetFile) || getDeclarationFileExtension(targetFile.fileName) === '.d.json.ts'));
+}
+/** The source file that declares a module: its value declaration, or its first declaration that is not an augmentation. */
+function getSourceFileOfModuleSymbol(symbol) {
+    let declaration = symbol.valueDeclaration;
+    if (declaration === undefined)
+        for (const d of symbol.declarations)
+            if (!(isAmbientModule(d) && isModuleAugmentationExternal(d)) && !isGlobalScopeAugmentation(d)) {
+                declaration = d;
+                break;
+            }
+    return declaration !== undefined ? getSourceFileOfNode(declaration) : undefined;
+}
+/** For a module only importable as default, the type of its namespace: an object with only `default`. */
+function getTypeWithSyntheticDefaultOnly(c, type, symbol, originalSymbol, moduleSpecifier) {
+    if (!isOnlyImportableAsDefault(c, moduleSpecifier, undefined) || isErrorType(c, type))
+        return undefined;
+    const key = 'defaultOnly:' + type.id;
+    const cached = c.moduleTypeCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const result = createDefaultPropertyWrapperForModule(c, symbol, originalSymbol, undefined);
+    c.moduleTypeCache.set(key, result);
+    return result;
+}
+/** `type` with a `default` member for the module, when the module may not have a real one. */
+function getTypeWithSyntheticDefaultImportType(c, type, symbol, originalSymbol, moduleSpecifier) {
+    if (isErrorType(c, type))
+        return type;
+    const key = 'synthetic:' + type.id;
+    const cached = c.moduleTypeCache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const file = getSourceFileDeclaration(originalSymbol);
+    let result = type;
+    if (canHaveSyntheticDefault(c, file, originalSymbol, false, moduleSpecifier)) {
+        const anonymousSymbol = c.newSymbol(2048 /* SymbolFlags.TypeLiteral */, "\uFFFEtype" /* InternalSymbolName.Type */);
+        const defaultContainingObject = createDefaultPropertyWrapperForModule(c, symbol, originalSymbol, anonymousSymbol);
+        c.symbolTypes.set(getSymbolId(anonymousSymbol), defaultContainingObject);
+        result = isValidSpreadType(c, type)
+            ? getSpreadType(c, type, defaultContainingObject, anonymousSymbol, 0 /* ObjectFlags.None */, false)
+            : defaultContainingObject;
+    }
+    c.moduleTypeCache.set(key, result);
+    return result;
+}
+function createDefaultPropertyWrapperForModule(c, symbol, originalSymbol, anonymousSymbol) {
+    const defaultSymbol = c.newSymbol(2097152 /* SymbolFlags.Alias */, "default" /* InternalSymbolName.Default */);
+    defaultSymbol.parent = originalSymbol;
+    const links = c.symbolLinks(defaultSymbol);
+    const id = defaultSymbol.id;
+    c.symbolNameTypes.set(id, getStringLiteralType(c, 'default'));
+    links.aliasTarget = resolveSymbol(c, symbol);
+    const members = new Map();
+    members.set("default" /* InternalSymbolName.Default */, defaultSymbol);
+    return createAnonymousType(c, anonymousSymbol, members, [], [], []);
+}
+function cloneTypeAsModuleType(c, symbol, moduleType) {
+    const result = c.newSymbol(symbol.flags, symbol.name);
+    result.declarations = symbol.declarations.slice();
+    result.valueDeclaration = symbol.valueDeclaration;
+    if (symbol.members !== undefined)
+        result.members = new Map(symbol.members);
+    if (symbol.exports !== undefined)
+        result.exports = new Map(symbol.exports);
+    result.parent = symbol.parent;
+    const resolved = resolveStructuredTypeMembers(c, moduleType);
+    c.symbolTypes.set(getSymbolId(result), createAnonymousType(c, result, resolved.members, [], [], resolved.indexInfos));
+    return result;
+}
+function getSourceFileDeclaration(symbol) {
+    if (symbol === undefined)
+        return undefined;
+    for (const d of symbol.declarations)
+        if (d.kind === 307 /* SyntaxKind.SourceFile */)
+            return d;
+    return undefined;
+}
+/** The module syntax of the import or export containing `usage`, or `None` for non-literals. */
+function getEmitSyntaxForModuleSpecifierExpression(c, usage) {
+    return isStringLiteralLike(usage)
+        ? c.host.getEmitSyntaxForUsageLocation(getSourceFileOfNode(usage), usage)
+        : ModuleKind.None;
+}
+/** Whether a default import of the module gets the module itself, as interop helpers make it. */
+function canHaveSyntheticDefault(c, file, moduleSymbol, dontResolveAlias, usage) {
+    const usageMode = file !== undefined ? getEmitSyntaxForModuleSpecifierExpression(c, usage) : ModuleKind.None;
+    if (file !== undefined && usageMode !== ModuleKind.None) {
+        const targetMode = c.host.getImpliedNodeFormatForEmit(file);
+        const moduleKind = getEmitModuleKind(c.compilerOptions);
+        // In Node.js, CommonJS modules always have a synthetic default when imported into ESM.
+        if (usageMode === ModuleKind.ESNext &&
+            targetMode === ModuleKind.CommonJS &&
+            moduleKind >= ModuleKind.Node16 &&
+            moduleKind <= ModuleKind.NodeNext)
+            return true;
+        // Two ES modules never have a synthetic default.
+        if (usageMode === ModuleKind.ESNext && targetMode === ModuleKind.ESNext)
+            return false;
+    }
+    if (file === undefined || file.isDeclarationFile) {
+        // A syntactic default export or an `__esModule` marker rules it out.
+        const defaultExport = resolveExportByName(c, moduleSymbol, "default" /* InternalSymbolName.Default */, undefined, true);
+        if (defaultExport !== undefined && hasSyntacticDefault(defaultExport))
+            return false;
+        return resolveExportByName(c, moduleSymbol, '__esModule', undefined, dontResolveAlias) === undefined;
+    }
+    // TypeScript files are emitted with `__esModule` unless they use `export =`.
+    if (!isInJSFile(file))
+        return hasExportAssignmentSymbol(moduleSymbol);
+    // JavaScript files without ES module syntax or an `__esModule` marker have one.
+    return ((file.externalModuleIndicator === undefined || file.externalModuleIndicator === file) &&
+        resolveExportByName(c, moduleSymbol, '__esModule', undefined, dontResolveAlias) === undefined);
+}
+function hasSyntacticDefault(symbol) {
+    for (const d of symbol.declarations)
+        if (isSyntacticDefault(d))
+            return true;
+    return false;
+}
+function isSyntacticDefault(node) {
+    return ((node.kind === 278 /* SyntaxKind.ExportAssignment */ && !node.isExportEquals) ||
+        hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */) ||
+        node.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
+        node.kind === 281 /* SyntaxKind.NamespaceExport */);
+}
+function hasExportAssignmentSymbol(moduleSymbol) {
+    return moduleSymbol.exports?.get("export=" /* InternalSymbolName.ExportEquals */) !== undefined;
+}
+function isShorthandAmbientModuleSymbol(symbol) {
+    const d = symbol?.valueDeclaration;
+    return d !== undefined && d.kind === 268 /* SyntaxKind.ModuleDeclaration */ && d.body === undefined;
+}
+// ---- Alias targets
+/** The symbol an alias declaration refers to, without resolving further aliases. */
+export function getTargetOfAliasDeclaration(c, node) {
+    if (node === undefined)
+        return undefined;
+    switch (node.kind) {
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 261 /* SyntaxKind.VariableDeclaration */:
+            return getTargetOfImportEqualsDeclaration(c, node);
+        case 274 /* SyntaxKind.ImportClause */:
+            return getTargetOfImportClause(c, node);
+        case 275 /* SyntaxKind.NamespaceImport */:
+            return getTargetOfNamespaceImport(c, node);
+        case 281 /* SyntaxKind.NamespaceExport */:
+            return getTargetOfNamespaceExport(c, node);
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 209 /* SyntaxKind.BindingElement */:
+            return getTargetOfImportSpecifier(c, node);
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return getTargetOfExportSpecifier(c, node, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true);
+        case 278 /* SyntaxKind.ExportAssignment */:
+            return withTypeOnlyMark(c, node, getTargetOfAliasLikeExpression(c, getExpression(node)));
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return withTypeOnlyMark(c, node, getTargetOfAliasLikeExpression(c, node.right));
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */: {
+            const resolved = resolveExternalModuleSymbol(c, getSymbol(node.parent), true);
+            markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+            return resolved;
+        }
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return resolveEntityName(c, getName(node), 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true, true, undefined);
+        case 303 /* SyntaxKind.PropertyAssignment */:
+            return getTargetOfAliasLikeExpression(c, getInitializer(node));
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+            const parent = node.parent;
+            if (parent !== undefined &&
+                parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+                parent.left === node &&
+                parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */)
+                return getTargetOfAliasLikeExpression(c, parent.right);
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function withTypeOnlyMark(c, node, resolved) {
+    markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+    return resolved;
+}
+function getTargetOfImportEqualsDeclaration(c, node) {
+    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */ || isExternalModuleImportEquals(node)) {
+        const moduleReference = isVariableDeclarationInitializedToRequire(node)
+            ? getInitializer(node).arguments.nodes[0]
+            : getExpression(node.moduleReference);
+        const immediate = resolveExternalModuleName(c, node, moduleReference, false);
+        const resolved = resolveExternalModuleSymbol(c, immediate, true);
+        const moduleKind = getEmitModuleKind(c.compilerOptions);
+        if (resolved !== undefined && moduleKind >= ModuleKind.Node20 && moduleKind <= ModuleKind.NodeNext) {
+            const moduleExports = getExportOfModule(c, resolved, "module.exports" /* InternalSymbolName.ModuleExports */, node, true);
+            if (moduleExports !== undefined)
+                return moduleExports;
+        }
+        markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+        return resolved;
+    }
+    const resolved = getSymbolOfPartOfRightHandSideOfImportEquals(c, node.moduleReference);
+    checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(c, node);
+    return resolved;
+}
+function isExternalModuleImportEquals(node) {
+    return (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */);
+}
+/**
+ * Resolves the entity name of `import a = b.c`: `b` alone or the left part of a longer name is a
+ * namespace, the whole name any meaning.
+ */
+export function getSymbolOfPartOfRightHandSideOfImportEquals(c, entityName) {
+    if (entityName.kind === 79 /* SyntaxKind.Identifier */ &&
+        entityName.parent !== undefined &&
+        entityName.parent.kind === 167 /* SyntaxKind.QualifiedName */ &&
+        entityName.parent.right === entityName)
+        entityName = entityName.parent;
+    if (entityName.kind === 79 /* SyntaxKind.Identifier */ || entityName.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        return resolveEntityName(c, entityName, 1920 /* SymbolFlags.Namespace */, false, true, undefined);
+    return resolveEntityName(c, entityName, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, false, true, undefined);
+}
+function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(c, node) {
+    let name = node.moduleReference;
+    for (;;) {
+        const typeOnlyDeclaration = getTypeOnlyDeclarationOfEntityName(c, name);
+        if (typeOnlyDeclaration !== undefined) {
+            const isExport = typeOnlyDeclaration.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
+                typeOnlyDeclaration.kind === 279 /* SyntaxKind.ExportDeclaration */;
+            const diagnostic = c.error(node.moduleReference, isExport
+                ? 308 /* Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type */
+                : 309 /* Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type */);
+            const typeOnlyName = typeOnlyDeclaration.kind === 279 /* SyntaxKind.ExportDeclaration */ ? '*' : getText(getName(typeOnlyDeclaration));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(typeOnlyDeclaration, isExport ? 306 /* Diagnostics.X_0_was_exported_here */ : 305 /* Diagnostics.X_0_was_imported_here */, [typeOnlyName]));
+            return;
+        }
+        if (name.kind !== 167 /* SyntaxKind.QualifiedName */)
+            return;
+        name = name.left;
+    }
+}
+function getTypeOnlyDeclarationOfEntityName(c, name) {
+    if (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 167 /* SyntaxKind.QualifiedName */)
+        return undefined;
+    const symbol = resolveEntityName(c, name, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true, true, undefined);
+    return symbol !== undefined ? getTypeOnlyAliasDeclaration(c, symbol) : undefined;
+}
+function getTargetOfImportClause(c, node) {
+    const moduleSymbol = resolveExternalModuleName(c, node, getModuleSpecifier(node.parent), false);
+    return moduleSymbol !== undefined ? getTargetOfModuleDefault(c, moduleSymbol, node, true) : undefined;
+}
+function getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias) {
+    const file = getSourceFileDeclaration(moduleSymbol);
+    const specifier = getModuleSpecifierForImportOrExport(node);
+    const exportDefaultSymbol = isShorthandAmbientModuleSymbol(moduleSymbol)
+        ? undefined
+        : resolveExportByName(c, moduleSymbol, "default" /* InternalSymbolName.Default */, node, dontResolveAlias);
+    if (specifier === undefined)
+        return exportDefaultSymbol;
+    const hasDefaultOnly = isOnlyImportableAsDefault(c, specifier, moduleSymbol);
+    const hasSyntheticDefault = canHaveSyntheticDefault(c, file, moduleSymbol, dontResolveAlias, specifier);
+    if (exportDefaultSymbol === undefined && !hasSyntheticDefault && !hasDefaultOnly) {
+        if (node.kind === 274 /* SyntaxKind.ImportClause */)
+            reportNonDefaultExport(c, moduleSymbol, node);
+        else {
+            const name = node.kind === 277 /* SyntaxKind.ImportSpecifier */ || node.kind === 282 /* SyntaxKind.ExportSpecifier */
+                ? getPropertyNameOrName(node)
+                : getName(node);
+            errorNoModuleMemberSymbol(c, moduleSymbol, moduleSymbol, node, name);
+        }
+    }
+    else if (hasSyntheticDefault || hasDefaultOnly) {
+        // A synthetic default overrides a real `default` member without an `__esModule` marker.
+        const resolved = resolveExternalModuleSymbol(c, moduleSymbol, dontResolveAlias) ??
+            resolveSymbolEx(c, moduleSymbol, dontResolveAlias);
+        markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+        return resolved;
+    }
+    markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+    return exportDefaultSymbol;
+}
+function reportNonDefaultExport(c, moduleSymbol, node) {
+    const local = getSymbol(node);
+    if (moduleSymbol.exports?.get(local.name) !== undefined) {
+        c.error(node, 757 /* Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead */, symbolToString(c, moduleSymbol), symbolToString(c, local));
+        return;
+    }
+    const diagnostic = c.error(getName(node), 148 /* Diagnostics.Module_0_has_no_default_export */, symbolToString(c, moduleSymbol));
+    const exportStar = moduleSymbol.exports?.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
+    if (exportStar === undefined)
+        return;
+    for (const d of exportStar.declarations) {
+        const specifier = getModuleSpecifier(d);
+        if (d.kind !== 279 /* SyntaxKind.ExportDeclaration */ || specifier === undefined)
+            continue;
+        const resolved = resolveExternalModuleName(c, d, specifier, false);
+        if (resolved !== undefined && resolved.exports?.get("default" /* InternalSymbolName.Default */) !== undefined) {
+            diagnostic.addRelatedInfo(createDiagnosticForNode(d, 151 /* Diagnostics.X_export_Asterisk_does_not_re_export_a_default */, []));
+            return;
+        }
+    }
+}
+function resolveExportByName(c, moduleSymbol, name, sourceNode, dontResolveAlias) {
+    const exportValue = moduleSymbol.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+    const exportSymbol = exportValue !== undefined
+        ? getPropertyOfTypeEx(c, getTypeOfSymbol(c, exportValue), name, true, false)
+        : moduleSymbol.exports?.get(name);
+    const resolved = exportSymbol !== undefined ? resolveSymbolEx(c, exportSymbol, dontResolveAlias) : undefined;
+    markSymbolOfAliasDeclarationIfTypeOnly(c, sourceNode, undefined);
+    return resolved;
+}
+function getTargetOfNamespaceImport(c, node) {
+    const moduleSpecifier = getModuleSpecifierForImportOrExport(node);
+    const immediate = resolveExternalModuleName(c, node, moduleSpecifier, false);
+    const resolved = resolveESModuleSymbol(c, immediate, node, moduleSpecifier);
+    markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+    return resolved;
+}
+function getTargetOfNamespaceExport(c, node) {
+    const moduleSpecifier = getModuleSpecifierForImportOrExport(node);
+    if (moduleSpecifier === undefined)
+        return undefined;
+    const immediate = resolveExternalModuleName(c, node, moduleSpecifier, false);
+    const resolved = resolveESModuleSymbol(c, immediate, node, moduleSpecifier);
+    markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+    return resolved;
+}
+function getTargetOfImportSpecifier(c, node) {
+    const name = getPropertyNameOrName(node);
+    if (node.kind === 277 /* SyntaxKind.ImportSpecifier */ && moduleExportNameIsDefault(name)) {
+        const specifier = getModuleSpecifierForImportOrExport(node);
+        if (specifier !== undefined) {
+            const moduleSymbol = resolveExternalModuleName(c, node, specifier, false);
+            if (moduleSymbol !== undefined)
+                return getTargetOfModuleDefault(c, moduleSymbol, node, true);
+        }
+    }
+    const root = node.kind === 209 /* SyntaxKind.BindingElement */ ? getRootDeclaration(node) : node.parent.parent.parent;
+    const resolved = getExternalModuleMember(c, root, node, true);
+    markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+    return resolved;
+}
+/** The export `specifier` names from the module of the import or export declaration `node`. */
+export function getExternalModuleMember(c, node, specifier, dontResolveAlias) {
+    const moduleSpecifier = isVariableDeclarationInitializedToRequire(node)
+        ? getInitializer(node).arguments.nodes[0]
+        : getExternalModuleName(node);
+    const moduleSymbol = resolveExternalModuleName(c, node, moduleSpecifier, false);
+    const name = specifier.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ? getName(specifier) : getPropertyNameOrName(specifier);
+    if (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 10 /* SyntaxKind.StringLiteral */)
+        return undefined;
+    const nameText = getText(name);
+    const targetSymbol = moduleSpecifier !== undefined ? resolveESModuleSymbol(c, moduleSymbol, specifier, moduleSpecifier) : undefined;
+    // The empty string is a valid module export name.
+    if (targetSymbol === undefined ||
+        moduleSymbol === undefined ||
+        (nameText === '' && name.kind !== 10 /* SyntaxKind.StringLiteral */))
+        return undefined;
+    if (isShorthandAmbientModuleSymbol(moduleSymbol))
+        return moduleSymbol;
+    // An `export =` module exports the members of its target's type.
+    const exportEquals = hasExportAssignmentSymbol(moduleSymbol);
+    let symbolFromVariable = exportEquals
+        ? getPropertyOfTypeEx(c, getTypeOfSymbol(c, targetSymbol), nameText, true, false)
+        : getPropertyOfVariable(c, targetSymbol, nameText);
+    if (symbolFromVariable !== undefined)
+        symbolFromVariable = resolveSymbolEx(c, symbolFromVariable, dontResolveAlias);
+    // Types and namespaces of an `export =` module live on the module symbol.
+    let symbolFromModule = getExportOfModule(c, exportEquals ? moduleSymbol : targetSymbol, nameText, specifier, dontResolveAlias);
+    if (symbolFromModule === undefined &&
+        nameText === "default" /* InternalSymbolName.Default */ &&
+        (isOnlyImportableAsDefault(c, moduleSpecifier, moduleSymbol) ||
+            canHaveSyntheticDefault(c, getSourceFileDeclaration(moduleSymbol), moduleSymbol, dontResolveAlias, moduleSpecifier)))
+        symbolFromModule =
+            resolveExternalModuleSymbol(c, moduleSymbol, dontResolveAlias) ??
+                resolveSymbolEx(c, moduleSymbol, dontResolveAlias);
+    const symbol = symbolFromModule === undefined
+        ? symbolFromVariable
+        : symbolFromVariable === undefined
+            ? symbolFromModule
+            : combineValueAndTypeSymbols(c, symbolFromVariable, symbolFromModule);
+    if ((specifier.kind === 277 /* SyntaxKind.ImportSpecifier */ || specifier.kind === 282 /* SyntaxKind.ExportSpecifier */) &&
+        nameText !== "default" /* InternalSymbolName.Default */ &&
+        isOnlyImportableAsDefault(c, moduleSpecifier, moduleSymbol))
+        c.error(name, 459 /* Diagnostics.Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0 */, moduleKindName(getEmitModuleKind(c.compilerOptions)));
+    else if (symbol === undefined)
+        errorNoModuleMemberSymbol(c, moduleSymbol, targetSymbol, node, name);
+    return symbol;
+}
+function getPropertyOfVariable(c, symbol, name) {
+    if ((symbol.flags & 3 /* SymbolFlags.Variable */) === 0)
+        return undefined;
+    const declaration = symbol.valueDeclaration;
+    const typeAnnotation = declaration !== undefined ? getType(declaration) : undefined;
+    if (typeAnnotation === undefined)
+        return undefined;
+    return resolveSymbol(c, getPropertyOfType(c, getTypeFromTypeNode(c, typeAnnotation), name));
+}
+/** A symbol with the value side of `valueSymbol` and the type and namespace sides of `typeSymbol`. */
+function combineValueAndTypeSymbols(c, valueSymbol, typeSymbol) {
+    if (valueSymbol === c.unknownSymbol && typeSymbol === c.unknownSymbol)
+        return c.unknownSymbol;
+    if ((typeSymbol.flags & 111551 /* SymbolFlags.Value */) !== 0)
+        return typeSymbol;
+    if ((valueSymbol.flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) !== 0)
+        return valueSymbol;
+    const result = c.newSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
+    const declarations = valueSymbol.declarations.slice();
+    for (const d of typeSymbol.declarations)
+        if (!declarations.includes(d))
+            declarations.push(d);
+    result.declarations = declarations;
+    result.parent = valueSymbol.parent ?? typeSymbol.parent;
+    result.valueDeclaration = valueSymbol.valueDeclaration;
+    if (typeSymbol.members !== undefined)
+        result.members = new Map(typeSymbol.members);
+    if (valueSymbol.exports !== undefined)
+        result.exports = new Map(valueSymbol.exports);
+    return result;
+}
+function getExportOfModule(c, symbol, nameText, specifier, dontResolveAlias) {
+    if ((symbol.flags & 1536 /* SymbolFlags.Module */) === 0)
+        return undefined;
+    const exportSymbol = getExportsOfSymbol(c, symbol).get(nameText);
+    const resolved = exportSymbol !== undefined ? resolveSymbolEx(c, exportSymbol, dontResolveAlias) : undefined;
+    const exportStarDeclaration = c.symbolLinks(symbol).typeOnlyExportStarMap?.get(nameText);
+    markSymbolOfAliasDeclarationIfTypeOnly(c, specifier, exportStarDeclaration);
+    return resolved;
+}
+function errorNoModuleMemberSymbol(c, moduleSymbol, targetSymbol, node, name) {
+    const moduleName = getFullyQualifiedName(c, moduleSymbol, node);
+    const declarationName = declarationNameToString(getSourceFileOfNode(name), name);
+    const suggestion = name.kind === 79 /* SyntaxKind.Identifier */
+        ? getSpellingSuggestionForName(c, getText(name), Array.from(getExportsOfModule(c, targetSymbol).values()), 2623475 /* SymbolFlags.ModuleMember */)
+        : undefined;
+    if (suggestion !== undefined) {
+        const suggestionName = symbolToString(c, suggestion);
+        const diagnostic = c.error(name, 856 /* Diagnostics.X_0_has_no_exported_member_named_1_Did_you_mean_2 */, moduleName, declarationName, suggestionName);
+        if (suggestion.valueDeclaration !== undefined)
+            diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [suggestionName]));
+        return;
+    }
+    if (moduleSymbol.exports?.get("default" /* InternalSymbolName.Default */) !== undefined) {
+        c.error(name, 758 /* Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead */, moduleName, declarationName);
+        return;
+    }
+    reportNonExportedMember(c, name, declarationName, moduleSymbol, moduleName);
+}
+function reportNonExportedMember(c, name, declarationName, moduleSymbol, moduleName) {
+    const locals = moduleSymbol.valueDeclaration !== undefined ? getLocals(moduleSymbol.valueDeclaration) : undefined;
+    const localSymbol = locals?.get(getText(name));
+    if (localSymbol === undefined) {
+        c.error(name, 483 /* Diagnostics.Module_0_has_no_exported_member_1 */, moduleName, declarationName);
+        return;
+    }
+    const exports = moduleSymbol.exports;
+    const exportEquals = exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+    if (exportEquals !== undefined) {
+        if (isSameReference(c, exportEquals, localSymbol))
+            reportInvalidImportEqualsExportMember(c, name, declarationName, moduleName);
+        else
+            c.error(name, 483 /* Diagnostics.Module_0_has_no_exported_member_1 */, moduleName, declarationName);
+        return;
+    }
+    let exportedSymbol;
+    if (exports !== undefined)
+        for (const s of exports.values())
+            if (isSameReference(c, s, localSymbol)) {
+                exportedSymbol = s;
+                break;
+            }
+    const diagnostic = exportedSymbol !== undefined
+        ? c.error(name, 626 /* Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2 */, moduleName, declarationName, symbolToString(c, exportedSymbol))
+        : c.error(name, 625 /* Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported */, moduleName, declarationName);
+    for (let i = 0; i < localSymbol.declarations.length; i++)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(localSymbol.declarations[i], i === 0 ? 860 /* Diagnostics.X_0_is_declared_here */ : 1357 /* Diagnostics.X_and_here */, [declarationName]));
+}
+function isSameReference(c, s1, s2) {
+    return (getMergedSymbol(c, resolveSymbol(c, getMergedSymbol(c, s1))) ===
+        getMergedSymbol(c, resolveSymbol(c, getMergedSymbol(c, s2))));
+}
+function reportInvalidImportEqualsExportMember(c, name, declarationName, moduleName) {
+    if (getEmitModuleKind(c.compilerOptions) >= ModuleKind.ES2015)
+        c.error(name, 743 /* Diagnostics.X_0_can_only_be_imported_by_using_a_default_import */, declarationName);
+    else if (isInJSFile(name))
+        c.error(name, 745 /* Diagnostics.X_0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import */, declarationName);
+    else
+        c.error(name, 760 /* Diagnostics.X_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import */, declarationName, declarationName, moduleName);
+}
+export function getTargetOfExportSpecifier(c, node, meaning, dontResolveAlias) {
+    const name = getPropertyNameOrName(node);
+    if (moduleExportNameIsDefault(name)) {
+        const specifier = getModuleSpecifierForImportOrExport(node);
+        if (specifier !== undefined) {
+            const moduleSymbol = resolveExternalModuleName(c, node, specifier, false);
+            if (moduleSymbol !== undefined)
+                return getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias);
+        }
+    }
+    const exportDeclaration = node.parent.parent;
+    let resolved;
+    if (exportDeclaration.moduleSpecifier !== undefined)
+        resolved = getExternalModuleMember(c, exportDeclaration, node, dontResolveAlias);
+    else if (name.kind !== 10 /* SyntaxKind.StringLiteral */)
+        resolved = resolveEntityName(c, name, meaning, false, dontResolveAlias, undefined);
+    markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
+    return resolved;
+}
+function getTargetOfAliasLikeExpression(c, expression) {
+    if (expression.kind === 232 /* SyntaxKind.ClassExpression */)
+        return checkExpressionCached(c, expression).symbol;
+    if (!isEntityNameOrEntityNameExpression(expression))
+        return undefined;
+    const aliasLike = resolveEntityName(c, expression, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true, true, undefined);
+    if (aliasLike !== undefined)
+        return aliasLike;
+    checkExpressionCached(c, expression);
+    return c.resolvedSymbols.get(expression.id);
+}
+function isEntityNameOrEntityNameExpression(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    if (node.kind === 167 /* SyntaxKind.QualifiedName */)
+        return true;
+    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const name = getName(node);
+        return (name !== undefined &&
+            name.kind === 79 /* SyntaxKind.Identifier */ &&
+            isEntityNameOrEntityNameExpression(getExpression(node)));
+    }
+    return false;
+}
+function getPropertyNameOrName(node) {
+    return getPropertyName(node) ?? getName(node);
+}
+function getModuleSpecifierForImportOrExport(node) {
+    switch (node.kind) {
+        case 274 /* SyntaxKind.ImportClause */:
+            return getModuleSpecifierOfDeclaration(node.parent);
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */: {
+            const reference = node.moduleReference;
+            return reference.kind === 284 /* SyntaxKind.ExternalModuleReference */ ? getExpression(reference) : undefined;
+        }
+        case 275 /* SyntaxKind.NamespaceImport */:
+            return getModuleSpecifierOfDeclaration(node.parent.parent);
+        case 277 /* SyntaxKind.ImportSpecifier */:
+            return getModuleSpecifierOfDeclaration(node.parent.parent.parent);
+        case 281 /* SyntaxKind.NamespaceExport */:
+            return getModuleSpecifierOfDeclaration(node.parent);
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return getModuleSpecifierOfDeclaration(node.parent.parent);
+    }
+    return undefined;
+}
+function getModuleSpecifierOfDeclaration(node) {
+    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+        return node.moduleSpecifier;
+    return getModuleSpecifier(node);
+}
+// ---- Type-only aliases
+/** Whether the declaration itself is written `import type` or `export type`. */
+export function isTypeOnlyImportOrExportDeclaration(node) {
+    switch (node.kind) {
+        case 277 /* SyntaxKind.ImportSpecifier */:
+            return getIsTypeOnly(node) || isTypeOnlyImportClause(node.parent.parent);
+        case 275 /* SyntaxKind.NamespaceImport */:
+            return isTypeOnlyImportClause(node.parent);
+        case 274 /* SyntaxKind.ImportClause */:
+            return isTypeOnlyImportClause(node);
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            return getIsTypeOnly(node);
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return getIsTypeOnly(node) || getIsTypeOnly(node.parent.parent);
+        case 279 /* SyntaxKind.ExportDeclaration */: {
+            const declaration = node;
+            return (declaration.isTypeOnly && declaration.moduleSpecifier !== undefined && declaration.exportClause === undefined);
+        }
+        case 281 /* SyntaxKind.NamespaceExport */:
+            return getIsTypeOnly(node.parent);
+    }
+    return false;
+}
+function isTypeOnlyImportClause(node) {
+    return node.kind === 274 /* SyntaxKind.ImportClause */ && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
+}
+/**
+ * Marks an alias declared `import type`/`export type`, or reached through a type-only `export *`,
+ * as type-only; returns whether it is.
+ */
+function markSymbolOfAliasDeclarationIfTypeOnly(c, aliasDeclaration, exportStarDeclaration) {
+    if (aliasDeclaration === undefined)
+        return false;
+    const sourceSymbol = getSymbol(aliasDeclaration);
+    if (sourceSymbol === undefined)
+        return false;
+    const links = c.symbolLinks(getMergedSymbol(c, sourceSymbol));
+    if (links.typeOnlyDeclaration === undefined && isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) {
+        links.typeOnlyDeclaration = aliasDeclaration;
+        return true;
+    }
+    if (links.typeOnlyDeclaration === undefined && exportStarDeclaration !== undefined) {
+        links.typeOnlyDeclaration = exportStarDeclaration;
+        return true;
+    }
+    return links.typeOnlyDeclaration !== undefined;
+}
+/** Marks the alias declaration an entity name is part of, if it is type-only. */
+export function markAliasDeclarationOfNameIfTypeOnly(c, name) {
+    let current = name;
+    while (current.parent !== undefined && current.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+        current = current.parent;
+    const parent = current.parent;
+    if (parent === undefined)
+        return;
+    switch (parent.kind) {
+        case 274 /* SyntaxKind.ImportClause */:
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 275 /* SyntaxKind.NamespaceImport */:
+        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 281 /* SyntaxKind.NamespaceExport */:
+            markSymbolOfAliasDeclarationIfTypeOnly(c, parent, undefined);
+    }
+}
+/** Resolves an alias whose target is an alias, carrying over the target's type-only declaration. */
+export function resolveIndirectionAlias(c, source, target) {
+    const result = getMergedSymbol(c, resolveAlias(c, target));
+    const targetDeclaration = c.symbolLinks(target).typeOnlyDeclaration;
+    if (targetDeclaration !== undefined) {
+        const sourceLinks = c.symbolLinks(source);
+        if (sourceLinks.typeOnlyDeclaration === undefined)
+            sourceLinks.typeOnlyDeclaration = targetDeclaration;
+    }
+    return result;
+}
+export function getTypeOnlyAliasDeclaration(c, symbol) {
+    if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0)
+        return undefined;
+    resolveAlias(c, symbol);
+    return c.symbolLinks(symbol).typeOnlyDeclaration;
+}
+/** The first type-only declaration along the alias chain of `symbol` before one with `meaning`. */
+export function getTypeOnlyAliasDeclarationOfMeaning(c, symbol, meaning) {
+    while ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && (symbol.flags & meaning) === 0) {
+        const resolved = resolveAlias(c, symbol);
+        const declaration = c.symbolLinks(symbol).typeOnlyDeclaration;
+        if (declaration !== undefined)
+            return declaration;
+        symbol = resolved;
+    }
+    return undefined;
+}
+function addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, name) {
+    if (typeOnlyDeclaration === undefined)
+        return;
+    const isExport = typeOnlyDeclaration.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
+        typeOnlyDeclaration.kind === 279 /* SyntaxKind.ExportDeclaration */ ||
+        typeOnlyDeclaration.kind === 281 /* SyntaxKind.NamespaceExport */;
+    diagnostic.addRelatedInfo(createDiagnosticForNode(typeOnlyDeclaration, isExport ? 306 /* Diagnostics.X_0_was_exported_here */ : 305 /* Diagnostics.X_0_was_imported_here */, [name]));
+}
+/** Reports a value use of a name that only resolves to a value through a type-only import or export. */
+export function checkTypeOnlyAliasUse(c, location, result, name) {
+    if ((result.flags & 2097152 /* SymbolFlags.Alias */) === 0 ||
+        (result.flags & 111551 /* SymbolFlags.Value */) !== 0 ||
+        isValidTypeOnlyAliasUseSite(location))
+        return;
+    const typeOnlyDeclaration = getTypeOnlyAliasDeclarationOfMeaning(c, result, 111551 /* SymbolFlags.Value */);
+    if (typeOnlyDeclaration === undefined)
+        return;
+    const isExport = typeOnlyDeclaration.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
+        typeOnlyDeclaration.kind === 279 /* SyntaxKind.ExportDeclaration */ ||
+        typeOnlyDeclaration.kind === 281 /* SyntaxKind.NamespaceExport */;
+    const diagnostic = c.error(location, isExport
+        ? 296 /* Diagnostics.X_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type */
+        : 295 /* Diagnostics.X_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type */, name);
+    addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, name);
+}
+export function isValidTypeOnlyAliasUseSite(useSite) {
+    return ((useSite.flags & (8388608 /* NodeFlags.Ambient */ | 4194304 /* NodeFlags.JSDoc */)) !== 0 ||
+        isPartOfTypeQuery(useSite) ||
+        isIdentifierInNonEmittingHeritageClause(useSite) ||
+        isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) ||
+        !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite)));
+}
+function isIdentifierInNonEmittingHeritageClause(node) {
+    if (node.kind !== 79 /* SyntaxKind.Identifier */)
+        return false;
+    let parent = node.parent;
+    while (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || parent.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+        parent = parent.parent;
+    return (parent.kind === 299 /* SyntaxKind.HeritageClause */ &&
+        (parent.token === 118 /* SyntaxKind.ImplementsKeyword */ ||
+            parent.parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */));
+}
+function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
+    let current = node;
+    while (current.kind === 79 /* SyntaxKind.Identifier */ || current.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        current = current.parent;
+    if (current.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+        return false;
+    if (hasSyntacticModifier(current.parent, 64 /* ModifierFlags.Abstract */))
+        return true;
+    const container = current.parent.parent.kind;
+    return container === 265 /* SyntaxKind.InterfaceDeclaration */ || container === 188 /* SyntaxKind.TypeLiteral */;
+}
+function isShorthandPropertyNameUseSite(useSite) {
+    return (useSite.kind === 79 /* SyntaxKind.Identifier */ &&
+        useSite.parent.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ &&
+        getName(useSite.parent) === useSite);
+}
+// ---- Referenced aliases
+/**
+ * Whether aliases are marked as referenced, which decides the imports emit keeps. Under
+ * verbatimModuleSyntax, emit keeps every import that isn't type-only, so they aren't.
+ */
+function marksReferencedAliases(c) {
+    return c.compilerOptions.verbatimModuleSyntax !== true;
+}
+/** Marks the aliases an identifier in an expression uses as referenced. */
+export function markIdentifierAliasReferencedInExpression(c, node) {
+    if (!marksReferencedAliases(c))
+        return;
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 || !shouldMarkIdentifierAliasReferenced(node))
+        return;
+    markIdentifierAliasReferenced(c, node);
+}
+/** Resolves the alias side of a referenced symbol, which may also be a local variable. */
+export function resolveAliasOfReference(c, symbol) {
+    if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && getDeclarationOfAliasSymbol(symbol) !== undefined)
+        resolveAlias(c, symbol);
+}
+function shouldMarkIdentifierAliasReferenced(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return true;
+    // The left of a property access is marked with the property.
+    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && getExpression(parent) === node)
+        return false;
+    // Names of type-only exports aren't emitted.
+    if (parent.kind === 282 /* SyntaxKind.ExportSpecifier */ && getIsTypeOnly(parent))
+        return false;
+    const greatGrandparent = parent.parent?.parent;
+    return !(greatGrandparent !== undefined &&
+        greatGrandparent.kind === 279 /* SyntaxKind.ExportDeclaration */ &&
+        getIsTypeOnly(greatGrandparent));
+}
+/**
+ * Marks the alias on the left of a property access as referenced, unless the access reads a const
+ * enum (or a module of only const enums) that is inlined.
+ */
+export function markPropertyAliasReferenced(c, location, prop, leftType) {
+    if (!marksReferencedAliases(c))
+        return;
+    if ((location.flags & 8388608 /* NodeFlags.Ambient */) !== 0 || isPartOfImportEqualsModuleReference(location))
+        return;
+    const left = location.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ? getExpression(location) : location.left;
+    if (left.kind !== 79 /* SyntaxKind.Identifier */ || getText(left) === 'this')
+        return;
+    const parentSymbol = getResolvedSymbol(c, left);
+    if (parentSymbol === c.unknownSymbol)
+        return;
+    if (c.isolatedModules ||
+        (c.preserveConstEnums && isExportOrExportExpression(location)) ||
+        (leftType.flags & 1 /* TypeFlags.Any */) !== 0 ||
+        leftType === c.silentNeverType) {
+        markAliasReferenced(c, parentSymbol, location);
+        return;
+    }
+    if (prop !== undefined &&
+        (isConstEnumOrConstEnumOnlyModule(prop) ||
+            ((prop.flags & 8 /* SymbolFlags.EnumMember */) !== 0 && location.parent.kind === 306 /* SyntaxKind.EnumMember */)))
+        return;
+    markAliasReferenced(c, parentSymbol, location);
+}
+function isPartOfImportEqualsModuleReference(location) {
+    let importEquals = location;
+    while (importEquals !== undefined && importEquals.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */)
+        importEquals = importEquals.parent;
+    if (importEquals === undefined)
+        return false;
+    const reference = importEquals.moduleReference;
+    for (let node = location; node !== undefined && node !== importEquals; node = node.parent)
+        if (node === reference)
+            return true;
+    return false;
+}
+function markIdentifierAliasReferenced(c, location) {
+    const symbol = getResolvedSymbol(c, location);
+    if (symbol !== c.argumentsSymbol && symbol !== c.unknownSymbol)
+        markAliasReferenced(c, symbol, location);
+}
+function markAliasReferenced(c, symbol, location) {
+    if (!marksReferencedAliases(c))
+        return;
+    if (!isNonLocalAlias(symbol, 111551 /* SymbolFlags.Value */) || isPartOfTypeQuery(location))
+        return;
+    const target = resolveAlias(c, symbol);
+    if ((getSymbolFlagsExcludingTypeOnly(c, symbol) & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) === 0)
+        return;
+    // An alias of a const enum can be elided unless the enum is kept.
+    if (c.isolatedModules ||
+        (c.preserveConstEnums && isExportOrExportExpression(location)) ||
+        !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(c, target)))
+        markAliasSymbolAsReferenced(c, symbol);
+}
+/**
+ * Marks an alias as referenced; an `import a = b.c` whose target is a value then references `b`,
+ * resolving it as a value.
+ */
+function markAliasSymbolAsReferenced(c, symbol) {
+    const links = c.symbolLinks(symbol);
+    if (links.aliasReferenced)
+        return;
+    links.aliasReferenced = true;
+    const node = getDeclarationOfAliasSymbol(symbol);
+    if (node !== undefined &&
+        node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */ &&
+        (getSymbolFlags(c, resolveSymbol(c, symbol)) & 111551 /* SymbolFlags.Value */) !== 0)
+        markIdentifierAliasReferenced(c, getFirstIdentifierOfEntityName(node.moduleReference));
+}
+function markExportAsReferenced(c, node) {
+    if (!marksReferencedAliases(c))
+        return;
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol === undefined)
+        return;
+    const target = resolveAlias(c, symbol);
+    if (target === c.unknownSymbol ||
+        ((getSymbolFlagsExcludingTypeOnly(c, symbol) & 111551 /* SymbolFlags.Value */) !== 0 &&
+            !isConstEnumOrConstEnumOnlyModule(target)))
+        markAliasSymbolAsReferenced(c, symbol);
+}
+function markExportSpecifierAliasReferenced(c, node, symbol, exportedName) {
+    if (!marksReferencedAliases(c))
+        return;
+    if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0 || getIsTypeOnly(node) || getIsTypeOnly(node.parent.parent))
+        return;
+    let target = symbol;
+    if (target !== undefined && (target.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
+        target = resolveAlias(c, target);
+    if (target === undefined || (getSymbolFlags(c, target) & 111551 /* SymbolFlags.Value */) !== 0) {
+        markExportAsReferenced(c, node);
+        markIdentifierAliasReferenced(c, exportedName);
+    }
+}
+function isConstEnumOrConstEnumOnlyModule(symbol) {
+    return (symbol.flags & (128 /* SymbolFlags.ConstEnum */ | 268435456 /* SymbolFlags.ConstEnumOnlyModule */)) !== 0;
+}
+function isExportOrExportExpression(location) {
+    for (let n = location; n !== undefined; n = n.parent) {
+        const parent = n.parent;
+        if (parent === undefined)
+            return false;
+        if (parent.kind === 278 /* SyntaxKind.ExportAssignment */)
+            return (getExpression(parent) === n && isEntityNameOrEntityNameExpression(n) && n.kind !== 167 /* SyntaxKind.QualifiedName */);
+        if (parent.kind === 282 /* SyntaxKind.ExportSpecifier */) {
+            if (getName(parent) === n || getPropertyName(parent) === n)
+                return true;
+        }
+    }
+    return false;
+}
+/** `getSymbolFlags`, stopping at the first type-only alias along the chain. */
+function getSymbolFlagsExcludingTypeOnly(c, symbol) {
+    return getSymbolFlagsEx(c, symbol, true, false);
+}
+/** `getSymbolFlags`, optionally stopping at type-only aliases or leaving out the symbol's own flags. */
+function getSymbolFlagsEx(c, symbol, excludeTypeOnlyMeanings, excludeLocalMeanings) {
+    const seen = new Set();
+    let flags = excludeLocalMeanings ? 0 /* SymbolFlags.None */ : symbol.flags;
+    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.has(target))
+                break;
+            seen.add(symbol);
+            seen.add(target);
+        }
+        flags |= target.flags;
+        symbol = target;
+    }
+    return flags;
+}
+// ---- Module exports
+/** Own exports plus those re-exported with `export *`; own exports shadow re-exported ones. */
+export function getExportsOfModuleWorker(c, moduleSymbol) {
+    const collector = new ExportCollector(c);
+    const exportEquals = moduleSymbol.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+    const originalModule = exportEquals !== undefined && resolveSymbolEx(c, exportEquals, false) !== undefined ? moduleSymbol : undefined;
+    const resolvedModule = resolveExternalModuleSymbol(c, moduleSymbol, false);
+    const exports = collector.visit(resolvedModule, undefined, false) ?? new Map();
+    // A CommonJS module with `export =` may also export types, stored on the original module.
+    if (originalModule !== undefined && originalModule.exports !== undefined && originalModule.exports.size > 1) {
+        for (const symbol of originalModule.exports.values()) {
+            if (symbol.name === "export=" /* InternalSymbolName.ExportEquals */ || symbol.name === "\uFFFEexport" /* InternalSymbolName.ExportStar */)
+                continue;
+            const flags = getSymbolFlags(c, symbol);
+            if ((flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) !== 0 &&
+                (flags & 111551 /* SymbolFlags.Value */) === 0 &&
+                !exports.has(symbol.name))
+                exports.set(symbol.name, symbol);
+        }
+    }
+    const typeOnlyExportStarMap = collector.typeOnlyExportStarMap;
+    if (typeOnlyExportStarMap !== undefined) {
+        for (const name of collector.nonTypeOnlyNames)
+            typeOnlyExportStarMap.delete(name);
+        c.symbolLinks(moduleSymbol).typeOnlyExportStarMap = typeOnlyExportStarMap;
+    }
+    return exports;
+}
+/** A name re-exported by several `export *` declarations. */
+class ExportCollision {
+    specifierText;
+    exportsWithDuplicate = [];
+    constructor(specifierText) {
+        this.specifierText = specifierText;
+    }
+}
+class ExportCollector {
+    c;
+    visited = [];
+    nonTypeOnlyNames = new Set();
+    typeOnlyExportStarMap = undefined;
+    constructor(c) {
+        this.c = c;
+    }
+    // Modules may re-export each other circularly.
+    visit(symbol, exportStar, isTypeOnly) {
+        if (!isTypeOnly && symbol !== undefined && symbol.exports !== undefined)
+            // Added before the visited check: `export *` overrides an earlier `export type *` of the same module.
+            for (const name of symbol.exports.keys())
+                this.nonTypeOnlyNames.add(name);
+        if (symbol === undefined || symbol.exports === undefined || this.visited.includes(symbol))
+            return undefined;
+        this.visited.push(symbol);
+        const symbols = new Map(symbol.exports);
+        const exportStars = symbol.exports.get("\uFFFEexport" /* InternalSymbolName.ExportStar */);
+        if (exportStars !== undefined) {
+            const nested = new Map();
+            const lookupTable = new Map();
+            for (const node of exportStars.declarations) {
+                const specifier = node.moduleSpecifier;
+                const resolved = resolveExternalModuleName(this.c, node, specifier, false);
+                const exported = this.visit(resolved, node, isTypeOnly || getIsTypeOnly(node));
+                this.extendExportSymbols(nested, exported, lookupTable, node);
+            }
+            for (const [id, collision] of lookupTable) {
+                // A module that exports the name itself resolves the ambiguity.
+                if (id === "export=" /* InternalSymbolName.ExportEquals */ || collision.exportsWithDuplicate.length === 0 || symbols.has(id))
+                    continue;
+                for (const node of collision.exportsWithDuplicate)
+                    this.c.error(node, 486 /* Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity */, collision.specifierText, id);
+            }
+            this.extendExportSymbols(symbols, nested, undefined, undefined);
+        }
+        if (exportStar !== undefined && getIsTypeOnly(exportStar)) {
+            if (this.typeOnlyExportStarMap === undefined)
+                this.typeOnlyExportStarMap = new Map();
+            for (const name of symbols.keys())
+                this.typeOnlyExportStarMap.set(name, exportStar);
+        }
+        return symbols;
+    }
+    extendExportSymbols(target, source, lookupTable, exportNode) {
+        if (source === undefined)
+            return;
+        for (const [id, sourceSymbol] of source) {
+            if (id === "default" /* InternalSymbolName.Default */)
+                continue;
+            const targetSymbol = target.get(id);
+            if (targetSymbol === undefined) {
+                target.set(id, sourceSymbol);
+                if (lookupTable !== undefined && exportNode !== undefined) {
+                    const specifier = exportNode.moduleSpecifier;
+                    lookupTable.set(id, new ExportCollision(getSourceTextOfNode(getSourceFileOfNode(specifier), specifier)));
+                }
+            }
+            else if (lookupTable !== undefined &&
+                exportNode !== undefined &&
+                resolveSymbol(this.c, targetSymbol) !== resolveSymbol(this.c, sourceSymbol))
+                lookupTable.get(id)?.exportsWithDuplicate.push(exportNode);
+        }
+    }
+}
+// ---- Import types and dynamic imports
+/** The type of `import("m")`, `import("m").T` or `typeof import("m").v`. */
+export function getTypeFromImportTypeNode(c, node) {
+    const type = c.resolvedTypes.get(node.id);
+    if (type !== undefined)
+        return type;
+    const importType = node;
+    if (!isLiteralImportTypeNode(node)) {
+        c.error(importType.argument, 107 /* Diagnostics.String_literal_expected */);
+        c.resolvedSymbols.set(node.id, c.unknownSymbol);
+        c.resolvedTypes.set(node.id, c.errorType);
+        return c.resolvedTypes.get(node.id);
+    }
+    const targetMeaning = importType.isTypeOf ? 111551 /* SymbolFlags.Value */ : 788968 /* SymbolFlags.Type */;
+    const literal = importType.argument.literal;
+    const innerModuleSymbol = resolveExternalModuleName(c, node, literal, false);
+    if (innerModuleSymbol === undefined) {
+        c.resolvedSymbols.set(node.id, c.unknownSymbol);
+        c.resolvedTypes.set(node.id, c.errorType);
+        return c.resolvedTypes.get(node.id);
+    }
+    const moduleSymbol = resolveExternalModuleSymbol(c, innerModuleSymbol, false);
+    const qualifier = importType.qualifier;
+    if (qualifier !== undefined && !nodeIsMissing(qualifier)) {
+        const nameChain = getIdentifierChain(qualifier);
+        let currentNamespace = moduleSymbol;
+        for (let i = 0; i < nameChain.length; i++) {
+            const current = nameChain[i];
+            const meaning = i === nameChain.length - 1 ? targetMeaning : 1920 /* SymbolFlags.Namespace */;
+            const merged = getMergedSymbol(c, resolveSymbol(c, currentNamespace));
+            const text = getText(current);
+            const next = importType.isTypeOf
+                ? getPropertyOfTypeEx(c, getTypeOfSymbol(c, merged), text, false, true)
+                : getSymbolOfMeaning(c, getExportsOfSymbol(c, merged), text, meaning);
+            if (next === undefined) {
+                c.error(current, 826 /* Diagnostics.Namespace_0_has_no_exported_member_1 */, getFullyQualifiedName(c, currentNamespace), declarationNameToString(getSourceFileOfNode(current), current));
+                c.resolvedTypes.set(node.id, c.errorType);
+                return c.resolvedTypes.get(node.id);
+            }
+            c.resolvedSymbols.set(current.id, next);
+            c.resolvedSymbols.set(current.parent.id, next);
+            currentNamespace = next;
+        }
+        c.resolvedTypes.set(node.id, resolveImportSymbolType(c, node, currentNamespace, targetMeaning));
+    }
+    else if ((getSymbolFlags(c, moduleSymbol) & targetMeaning) !== 0) {
+        c.resolvedTypes.set(node.id, resolveImportSymbolType(c, node, moduleSymbol, targetMeaning));
+    }
+    else {
+        c.error(node, targetMeaning === 111551 /* SymbolFlags.Value */
+            ? 274 /* Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here */
+            : 275 /* Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0 */, getText(literal));
+        c.resolvedSymbols.set(node.id, c.unknownSymbol);
+        c.resolvedTypes.set(node.id, c.errorType);
+    }
+    return c.resolvedTypes.get(node.id);
+}
+function getIdentifierChain(node) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return [node];
+    const chain = getIdentifierChain(node.left);
+    chain.push(node.right);
+    return chain;
+}
+function resolveImportSymbolType(c, node, symbol, meaning) {
+    const resolvedSymbol = resolveSymbol(c, symbol);
+    c.resolvedSymbols.set(node.id, resolvedSymbol);
+    // The alias itself caches the type of a value.
+    if (meaning === 111551 /* SymbolFlags.Value */)
+        return getTypeOfSymbol(c, symbol);
+    return getTypeReferenceType(c, node, resolvedSymbol);
+}
+/** `import(specifier, options)`: a promise of the module namespace. */
+export function checkImportCallExpression(c, node) {
+    const args = node.arguments.nodes;
+    if (args.length === 0)
+        return createPromiseReturnType(c, node, c.anyType);
+    const specifier = args[0];
+    const specifierType = checkExpressionCached(c, specifier);
+    const optionsType = args.length > 1 ? checkExpressionCached(c, args[1]) : undefined;
+    // Extra arguments are a grammar error; check them for completions.
+    for (let i = 2; i < args.length; i++)
+        checkExpressionCached(c, args[i]);
+    if ((specifierType.flags & 12 /* TypeFlags.Nullable */) !== 0 || !isTypeAssignableTo(c, specifierType, c.stringType))
+        c.error(specifier, 1707 /* Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0 */, typeToString(c, specifierType));
+    if (optionsType !== undefined) {
+        const importCallOptionsType = getCachedGlobalType(c, 'ImportCallOptions', 0, true);
+        if (importCallOptionsType !== c.emptyObjectType)
+            checkTypeAssignableTo(c, optionsType, getNullableType(c, importCallOptionsType, 4 /* TypeFlags.Undefined */), args[1], undefined);
+        if (args[1].kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+            for (const property of args[1].properties.nodes) {
+                const name = getName(property);
+                if (property.kind === 303 /* SyntaxKind.PropertyAssignment */ &&
+                    name !== undefined &&
+                    name.kind === 79 /* SyntaxKind.Identifier */ &&
+                    getText(name) === 'assert') {
+                    c.error(name, 1000 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
+                    break;
+                }
+            }
+    }
+    const moduleSymbol = resolveExternalModuleName(c, node, specifier, false);
+    if (moduleSymbol !== undefined) {
+        const esModuleSymbol = resolveExternalModuleSymbol(c, moduleSymbol, true);
+        if (esModuleSymbol !== undefined)
+            return createPromiseReturnType(c, node, getTypeWithSyntheticDefaultOnly(c, getTypeOfSymbol(c, esModuleSymbol), esModuleSymbol, moduleSymbol, specifier) ??
+                getTypeWithSyntheticDefaultImportType(c, getTypeOfSymbol(c, esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
+    }
+    return createPromiseReturnType(c, node, c.anyType);
+}
+function createPromiseReturnType(c, node, promisedType) {
+    const promiseType = createPromiseType(c, promisedType);
+    if (promiseType !== c.unknownType)
+        return promiseType;
+    c.error(node, 843 /* Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option */);
+    return c.errorType;
+}
+// ---- JSDoc links
+/** The symbol a `{@link}` name refers to, as an entity or a member of one. */
+export function resolveJSDocMemberName(c, name) {
+    if (name === undefined || (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 167 /* SyntaxKind.QualifiedName */))
+        return undefined;
+    const meaning = 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 111551 /* SymbolFlags.Value */;
+    const symbol = resolveEntityName(c, name, meaning, true, true, getHostSignatureFromJSDoc(name));
+    if (symbol !== undefined)
+        return symbol;
+    if (name.kind !== 167 /* SyntaxKind.QualifiedName */)
+        return undefined;
+    const left = resolveJSDocMemberName(c, name.left);
+    if (left === undefined)
+        return undefined;
+    let type;
+    if ((left.flags & 111551 /* SymbolFlags.Value */) !== 0) {
+        const prototype = getPropertyOfType(c, getTypeOfSymbol(c, left), 'prototype');
+        if (prototype !== undefined)
+            type = getTypeOfSymbol(c, prototype);
+    }
+    return getPropertyOfType(c, type ?? getDeclaredTypeOfSymbol(c, left), name.right.text);
+}
+export function getHostSignatureFromJSDoc(node) {
+    let current = node;
+    while (current !== undefined && current.kind !== 315 /* SyntaxKind.JSDoc */)
+        current = current.parent;
+    const host = current?.parent;
+    return host !== undefined && isFunctionLike(host) ? host : undefined;
+}
+// ---- Meta properties
+/** `import.meta` and `new.target`. */
+export function checkMetaProperty(c, node) {
+    const meta = node;
+    if (meta.keywordToken === 104 /* SyntaxKind.NewKeyword */)
+        return checkNewTargetMetaProperty(c, node);
+    // `import.defer` is only valid as a callee.
+    if (meta.name.text === 'defer')
+        return c.errorType;
+    const moduleKind = getEmitModuleKind(c.compilerOptions);
+    if (moduleKind >= ModuleKind.Node16 && moduleKind <= ModuleKind.NodeNext) {
+        if (c.host.getImpliedNodeFormatForEmit(getSourceFileOfNode(node)) === ModuleKind.CommonJS)
+            c.error(node, 385 /* Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output */);
+    }
+    else if (moduleKind < ModuleKind.ES2020 && moduleKind !== ModuleKind.System)
+        c.error(node, 277 /* Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_node18_node20_or_nodenext */);
+    return meta.name.text === 'meta' ? getCachedGlobalType(c, 'ImportMeta', 0, true) : c.errorType;
+}
+export function checkNewTargetMetaProperty(c, node) {
+    const container = getThisContainer(node, false, false);
+    if (container.kind !== 177 /* SyntaxKind.Constructor */ &&
+        container.kind !== 263 /* SyntaxKind.FunctionDeclaration */ &&
+        container.kind !== 219 /* SyntaxKind.FunctionExpression */) {
+        c.error(node, 1816 /* Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor */, 'new.target');
+        return c.errorType;
+    }
+    const symbol = getSymbolOfDeclaration(c, container.kind === 177 /* SyntaxKind.Constructor */ ? container.parent : container);
+    return symbol !== undefined ? getTypeOfSymbol(c, symbol) : c.errorType;
+}
+// ---- Import and export declarations
+/**
+ * Whether an import or export with a module specifier is in a valid place with a valid specifier;
+ * the grammar checker reports the errors.
+ */
+function isValidExternalImportOrExportDeclaration(node) {
+    const moduleName = getExternalModuleName(node);
+    if (moduleName === undefined || nodeIsMissing(moduleName) || moduleName.kind !== 10 /* SyntaxKind.StringLiteral */)
+        return false;
+    const parent = node.parent;
+    const inAmbientExternalModule = parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
+    if (parent.kind !== 307 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule)
+        return false;
+    if (inAmbientExternalModule &&
+        isExternalModuleNameRelative(getText(moduleName)) &&
+        !isModuleAugmentationExternal(parent.parent))
+        return false;
+    if (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+        return true;
+    const attributes = getImportAttributes(node);
+    if (attributes === undefined)
+        return true;
+    for (const attribute of attributes.attributes.nodes)
+        if (attribute.value.kind !== 10 /* SyntaxKind.StringLiteral */)
+            return false;
+    return true;
+}
+function isInModuleElementContext(node) {
+    const parent = node.parent.kind;
+    return (parent === 307 /* SyntaxKind.SourceFile */ || parent === 269 /* SyntaxKind.ModuleBlock */ || parent === 268 /* SyntaxKind.ModuleDeclaration */);
+}
+function getImportAttributes(node) {
+    if (node.kind === 273 /* SyntaxKind.ImportDeclaration */ || node.kind === 346 /* SyntaxKind.JSImportDeclaration */)
+        return node.attributes;
+    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+        return node.attributes;
+    return undefined;
+}
+/** Whether the grammar checker reports the import clause, which skips its bindings. */
+function hasImportClauseGrammarError(c, node) {
+    const namedBindings = node.namedBindings;
+    if (node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */) {
+        if ((node.flags & 4194304 /* NodeFlags.JSDoc */) === 0 && node.name !== undefined && namedBindings !== undefined)
+            return !hasParseErrors(node);
+        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
+            for (const specifier of namedBindings.elements.nodes)
+                if (getIsTypeOnly(specifier))
+                    return !hasParseErrors(node);
+    }
+    else if (node.phaseModifier === 166 /* SyntaxKind.DeferKeyword */) {
+        if (node.name !== undefined)
+            return !hasParseErrors(node);
+        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
+            return !hasParseErrors(node);
+        const moduleKind = getEmitModuleKind(c.compilerOptions);
+        if (moduleKind !== ModuleKind.ESNext && moduleKind !== ModuleKind.Preserve)
+            return !hasParseErrors(node);
+    }
+    return false;
+}
+function hasParseErrors(node) {
+    return getSourceFileOfNode(node).diagnostics.length > 0;
+}
+export function checkImportDeclaration(c, node) {
+    if (!isInModuleElementContext(node) || !isValidExternalImportOrExportDeclaration(node)) {
+        checkImportAttributes(c, node);
+        return;
+    }
+    const declaration = node;
+    const clause = declaration.importClause;
+    if (clause !== undefined && !hasImportClauseGrammarError(c, clause)) {
+        if (clause.name !== undefined)
+            checkImportBinding(c, clause);
+        const namedBindings = clause.namedBindings;
+        let resolvedModule;
+        const emittedAsCommonJS = c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS;
+        let needsImportStar = false;
+        if (namedBindings !== undefined) {
+            if (namedBindings.kind === 275 /* SyntaxKind.NamespaceImport */) {
+                checkImportBinding(c, namedBindings);
+                if (emittedAsCommonJS) {
+                    needsImportStar = true;
+                    checkExternalEmitHelpers(c, node, 1024 /* ExternalEmitHelpers.ImportStar */);
+                }
+            }
+            else {
+                resolvedModule = resolveExternalModuleName(c, node, declaration.moduleSpecifier, false);
+                if (resolvedModule !== undefined)
+                    for (const binding of namedBindings.elements.nodes)
+                        checkImportBinding(c, binding);
+            }
+        }
+        if (clause.name !== undefined && !needsImportStar && emittedAsCommonJS)
+            checkExternalEmitHelpers(c, node, 2048 /* ExternalEmitHelpers.ImportDefault */);
+        const moduleKind = getEmitModuleKind(c.compilerOptions);
+        if (!isTypeOnly(clause) &&
+            moduleKind >= ModuleKind.Node18 &&
+            moduleKind <= ModuleKind.NodeNext &&
+            isOnlyImportableAsDefault(c, declaration.moduleSpecifier, resolvedModule) &&
+            !hasTypeJsonImportAttribute(declaration))
+            c.error(declaration.moduleSpecifier, 458 /* Diagnostics.Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0 */, moduleKindName(moduleKind));
+    }
+    else if (clause === undefined && c.compilerOptions.noUncheckedSideEffectImports !== false)
+        resolveExternalModuleNameWorker(c, node, declaration.moduleSpecifier, 1002 /* Diagnostics.Cannot_find_module_or_type_declarations_for_side_effect_import_of_0 */, false, false);
+    checkImportAttributes(c, node);
+}
+function hasTypeJsonImportAttribute(node) {
+    const attributes = getImportAttributes(node);
+    if (attributes === undefined)
+        return false;
+    for (const attribute of attributes.attributes.nodes) {
+        const value = attribute.value;
+        if (getText(getName(attribute)) === 'type' && isStringLiteralLike(value) && getText(value) === 'json')
+            return true;
+    }
+    return false;
+}
+function checkImportBinding(c, node) {
+    checkCollisionsForDeclarationName(c, node, getName(node));
+    checkAliasSymbol(c, node);
+    if (node.kind === 277 /* SyntaxKind.ImportSpecifier */ &&
+        moduleExportNameIsDefault(getPropertyNameOrName(node)) &&
+        c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS)
+        checkExternalEmitHelpers(c, node, 2048 /* ExternalEmitHelpers.ImportDefault */);
+}
+/** Import attributes must be assignable to the global `ImportAttributes`. */
+function checkImportAttributes(c, declaration) {
+    const node = getImportAttributes(declaration);
+    if (node === undefined)
+        return;
+    const importAttributesType = getCachedGlobalType(c, 'ImportAttributes', 0, true);
+    if (importAttributesType !== c.emptyObjectType)
+        checkTypeAssignableTo(c, getTypeFromImportAttributes(c, node), getNullableType(c, importAttributesType, 4 /* TypeFlags.Undefined */), node, undefined);
+}
+function getTypeFromImportAttributes(c, node) {
+    if (c.resolvedTypes.get(node.id) === undefined) {
+        const symbol = c.newSymbol(4096 /* SymbolFlags.ObjectLiteral */, "\uFFFEimportAttributes" /* InternalSymbolName.ImportAttributes */);
+        const members = new Map();
+        for (const attribute of node.attributes.nodes) {
+            const name = getText(attribute.name);
+            const member = c.newSymbol(4 /* SymbolFlags.Property */, name);
+            c.symbolTypes.set(getSymbolId(member), getRegularTypeOfLiteralType(c, checkExpression(c, attribute.value)));
+            members.set(name, member);
+        }
+        const type = createAnonymousType(c, symbol, members, [], [], []);
+        type.objectFlags |= 128 /* ObjectFlags.ObjectLiteral */ | 262144 /* ObjectFlags.NonInferrableType */;
+        c.resolvedTypes.set(node.id, type);
+    }
+    return c.resolvedTypes.get(node.id);
+}
+export function checkImportEqualsDeclaration(c, node) {
+    if (!isInModuleElementContext(node))
+        return;
+    const declaration = node;
+    const reference = declaration.moduleReference;
+    const isExternal = reference.kind === 284 /* SyntaxKind.ExternalModuleReference */;
+    if (shouldCheckErasableSyntax(c, node) && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+        c.error(node, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */);
+    if (isExternal && !isValidExternalImportOrExportDeclaration(node))
+        return;
+    checkImportBinding(c, node);
+    if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */) && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+        markExportAsReferenced(c, node);
+    if (isExternal)
+        return;
+    const target = resolveAlias(c, getSymbolOfDeclaration(c, node));
+    if (target === c.unknownSymbol)
+        return;
+    const targetFlags = getSymbolFlags(c, target);
+    if ((targetFlags & 111551 /* SymbolFlags.Value */) !== 0) {
+        // A value target must not be hidden by a local declaration of the same name.
+        const moduleName = getFirstIdentifierOfEntityName(reference);
+        const resolved = resolveEntityName(c, moduleName, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */, false, false, undefined);
+        if (resolved !== undefined && (resolved.flags & 1920 /* SymbolFlags.Namespace */) === 0)
+            c.error(moduleName, 605 /* Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name */, declarationNameToString(getSourceFileOfNode(moduleName), moduleName));
+    }
+    if ((targetFlags & 788968 /* SymbolFlags.Type */) !== 0)
+        checkTypeNameIsReserved(c, declaration.name, 606 /* Diagnostics.Import_name_cannot_be_0 */);
+}
+function getFirstIdentifierOfEntityName(node) {
+    let current = node;
+    while (current.kind === 167 /* SyntaxKind.QualifiedName */)
+        current = current.left;
+    return current;
+}
+/** The string literal name of `export * as "x" from`, which module es2015 and es2020 don't support. */
+function checkNamespaceExportName(c, name) {
+    if (name === undefined || name.kind !== 10 /* SyntaxKind.StringLiteral */)
+        return;
+    const moduleKind = getEmitModuleKind(c.compilerOptions);
+    if ((moduleKind === ModuleKind.ES2015 || moduleKind === ModuleKind.ES2020) &&
+        !getSourceFileOfNode(name).isDeclarationFile)
+        grammarErrorOnNode(c, name, 1872 /* Diagnostics.String_literal_import_and_export_names_are_not_supported_when_the_module_flag_is_set_to_es2015_or_es2020 */);
+}
+export function checkExportDeclaration(c, node) {
+    if (!isInModuleElementContext(node))
+        return;
+    const declaration = node;
+    if (declaration.moduleSpecifier === undefined || isValidExternalImportOrExportDeclaration(node)) {
+        const clause = declaration.exportClause;
+        if (clause !== undefined && clause.kind === 280 /* SyntaxKind.NamedExports */) {
+            for (const specifier of clause.elements.nodes)
+                checkExportSpecifier(c, specifier);
+        }
+        else {
+            const moduleSymbol = resolveExternalModuleName(c, node, declaration.moduleSpecifier, false);
+            if (moduleSymbol !== undefined && hasExportAssignmentSymbol(moduleSymbol))
+                c.error(declaration.moduleSpecifier, 658 /* Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk */, symbolToString(c, moduleSymbol));
+            else if (clause !== undefined) {
+                checkAliasSymbol(c, clause);
+                checkNamespaceExportName(c, getName(clause));
+            }
+            if (c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS)
+                checkExternalEmitHelpers(c, node, clause !== undefined ? 1024 /* ExternalEmitHelpers.ImportStar */ : 512 /* ExternalEmitHelpers.ExportStar */);
+        }
+    }
+    checkImportAttributes(c, node);
+}
+function checkExportSpecifier(c, node) {
+    checkAliasSymbol(c, node);
+    if (node.parent.parent.moduleSpecifier !== undefined) {
+        if (c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS &&
+            moduleExportNameIsDefault(getPropertyNameOrName(node)))
+            checkExternalEmitHelpers(c, node, 2048 /* ExternalEmitHelpers.ImportDefault */);
+        return;
+    }
+    const exportedName = getPropertyNameOrName(node);
+    // `export { "x" }` is a syntax error.
+    if (exportedName.kind === 10 /* SyntaxKind.StringLiteral */)
+        return;
+    // The immediate symbol of the name, without following aliases.
+    const symbol = resolveName(c, exportedName, getText(exportedName), 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */, undefined, true, false);
+    if (symbol !== undefined &&
+        (symbol === c.undefinedSymbol ||
+            symbol === c.globalThisSymbol ||
+            (symbol.declarations.length > 0 && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))))
+        c.error(exportedName, 795 /* Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module */, getText(exportedName));
+    else
+        markExportSpecifierAliasReferenced(c, node, symbol, exportedName);
+}
+export function getDeclarationContainer(node) {
+    let current = getRootDeclaration(node);
+    for (;;) {
+        const parent = current.parent;
+        if (parent === undefined)
+            return current;
+        switch (current.kind) {
+            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclarationList */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 274 /* SyntaxKind.ImportClause */:
+                current = parent;
+                continue;
+        }
+        return parent;
+    }
+}
+/** `export = e` and `export default e`; the grammar checker reports misplaced ones. */
+export function checkExportAssignment(c, node) {
+    if (!isInModuleElementContext(node))
+        return;
+    const declaration = node;
+    const isExportEquals = declaration.isExportEquals;
+    const ambient = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
+    if (shouldCheckErasableSyntax(c, node) && isExportEquals && !ambient)
+        c.error(node, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */);
+    const container = node.parent.kind === 307 /* SyntaxKind.SourceFile */ ? node.parent : node.parent.parent;
+    if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container))
+        return;
+    const verbatimModuleSyntax = c.compilerOptions.verbatimModuleSyntax === true;
+    const isIllegalExportDefaultInCJS = !isExportEquals &&
+        !ambient &&
+        verbatimModuleSyntax &&
+        c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS;
+    const expression = declaration.expression;
+    if (expression.kind === 79 /* SyntaxKind.Identifier */) {
+        const id = expression;
+        const resolved = resolveEntityName(c, id, 1073741823 /* SymbolFlags.All */, true, true, node);
+        if (resolved !== undefined) {
+            const sym = getExportSymbolOfValueSymbolIfExported(c, resolved);
+            if (!ambient)
+                markAliasReferenced(c, sym, id);
+            const typeOnlyDeclaration = getTypeOnlyAliasDeclarationOfMeaning(c, sym, 111551 /* SymbolFlags.Value */);
+            const name = getText(id);
+            // A non-value is exported as a type, like `export { Id as default }`.
+            if ((getSymbolFlags(c, sym) & 111551 /* SymbolFlags.Value */) !== 0) {
+                checkExpressionCached(c, id);
+                if (!isIllegalExportDefaultInCJS && !ambient && verbatimModuleSyntax && typeOnlyDeclaration !== undefined)
+                    c.error(id, isExportEquals
+                        ? 232 /* Diagnostics.An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration */
+                        : 234 /* Diagnostics.An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration */, name);
+            }
+            else if (!isIllegalExportDefaultInCJS && !ambient && verbatimModuleSyntax)
+                c.error(id, isExportEquals
+                    ? 231 /* Diagnostics.An_export_declaration_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type */
+                    : 233 /* Diagnostics.An_export_default_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type */, name);
+            if (!isIllegalExportDefaultInCJS && !ambient && c.isolatedModules && (sym.flags & 111551 /* SymbolFlags.Value */) === 0)
+                checkIsolatedModulesExportAssignment(c, node, sym, typeOnlyDeclaration, isExportEquals);
+        }
+        else
+            checkExpressionCached(c, id);
+    }
+    else
+        checkExpressionCached(c, expression);
+    if (isIllegalExportDefaultInCJS)
+        c.error(node, verbatimModuleSyntaxErrorMessage(node));
+    checkExternalModuleExports(c, container);
+    // A JSDoc `@type` on `export default`.
+    const typeNode = getType(node);
+    if (typeNode !== undefined) {
+        const expr = getExpression(node);
+        checkTypeAssignableToAndOptionallyElaborate(c, checkExpressionCached(c, expr), getTypeFromTypeNode(c, typeNode), expr, expr);
+    }
+}
+function checkIsolatedModulesExportAssignment(c, node, sym, typeOnlyDeclaration, isExportEquals) {
+    const id = getExpression(node);
+    const name = getText(id);
+    const nonLocalMeanings = getSymbolFlagsEx(c, sym, false, true);
+    const sameFile = typeOnlyDeclaration !== undefined && getSourceFileOfNode(typeOnlyDeclaration) === getSourceFileOfNode(node);
+    if ((sym.flags & 2097152 /* SymbolFlags.Alias */) !== 0 &&
+        (nonLocalMeanings & 788968 /* SymbolFlags.Type */) !== 0 &&
+        (nonLocalMeanings & 111551 /* SymbolFlags.Value */) === 0 &&
+        !sameFile)
+        c.error(id, isExportEquals
+            ? 240 /* Diagnostics.X_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported */
+            : 241 /* Diagnostics.X_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default */, name, getIsolatedModulesLikeFlagName(c));
+    else if (typeOnlyDeclaration !== undefined && !sameFile)
+        addTypeOnlyDeclarationRelatedInfo(c.error(id, isExportEquals
+            ? 238 /* Diagnostics.X_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported */
+            : 239 /* Diagnostics.X_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default */, name, getIsolatedModulesLikeFlagName(c)), typeOnlyDeclaration, name);
+}
+/** Reports aliases that conflict with local declarations, and type-only rules of isolated modules. */
+export function checkAliasSymbol(c, node) {
+    const aliasSymbol = getSymbolOfDeclaration(c, node);
+    if (aliasSymbol === undefined)
+        return;
+    const target = resolveAlias(c, aliasSymbol);
+    if (target === c.unknownSymbol)
+        return;
+    // The local symbol merges other local (and exported) declarations, whose meanings the target can't have.
+    const symbol = getMergedSymbol(c, aliasSymbol.exportSymbol ?? aliasSymbol);
+    const targetFlags = getSymbolFlags(c, target);
+    // Type-only imports and exports are grammar errors in JavaScript.
+    if (isInJSFile(node) && (targetFlags & 111551 /* SymbolFlags.Value */) === 0 && !isTypeOnlyImportOrExportDeclaration(node)) {
+        reportJSTypeAlias(c, node, symbol);
+        return;
+    }
+    const excludedMeanings = ((symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) !== 0 ? 111551 /* SymbolFlags.Value */ : 0) |
+        ((symbol.flags & 788968 /* SymbolFlags.Type */) !== 0 ? 788968 /* SymbolFlags.Type */ : 0) |
+        ((symbol.flags & 1920 /* SymbolFlags.Namespace */) !== 0 ? 1920 /* SymbolFlags.Namespace */ : 0);
+    if ((targetFlags & excludedMeanings) !== 0)
+        c.error(node, node.kind === 282 /* SyntaxKind.ExportSpecifier */
+            ? 646 /* Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 */
+            : 608 /* Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0 */, symbolToString(c, symbol));
+    else if (node.kind !== 282 /* SyntaxKind.ExportSpecifier */ &&
+        c.compilerOptions.isolatedModules === true &&
+        !isPartOfTypeOnlyImportOrExportDeclaration(node) &&
+        (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) !== 0)
+        // A transpiler sees a value import that collides with the local value.
+        c.error(node, 985 /* Diagnostics.Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled */, symbolToString(c, symbol), getIsolatedModulesLikeFlagName(c));
+    if (c.isolatedModules && !isTypeOnlyImportOrExportDeclaration(node) && (node.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+        checkIsolatedModulesAlias(c, node, symbol, target, targetFlags);
+    if (node.kind === 277 /* SyntaxKind.ImportSpecifier */)
+        checkDeprecatedImportSpecifier(c, node, symbol);
+}
+function reportJSTypeAlias(c, node, symbol) {
+    const errorNode = getPropertyName(node) ?? getName(node) ?? node;
+    if (node.kind === 282 /* SyntaxKind.ExportSpecifier */) {
+        c.error(errorNode, 1859 /* Diagnostics.Types_cannot_appear_in_export_declarations_in_JavaScript_files */);
+        return;
+    }
+    const identifierText = errorNode.kind === 79 /* SyntaxKind.Identifier */ ? getText(errorNode) : symbol.name;
+    let specifierText = '...';
+    let declaration = node;
+    while (declaration !== undefined &&
+        declaration.kind !== 273 /* SyntaxKind.ImportDeclaration */ &&
+        declaration.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        declaration.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+        declaration = declaration.parent;
+    if (declaration !== undefined) {
+        const specifier = declaration.kind === 261 /* SyntaxKind.VariableDeclaration */
+            ? isVariableDeclarationInitializedToRequire(declaration)
+                ? getInitializer(declaration).arguments.nodes[0]
+                : undefined
+            : getExternalModuleName(declaration);
+        if (specifier !== undefined && isStringLiteralLike(specifier))
+            specifierText = getText(specifier);
+    }
+    let importText = 'import("' + specifierText + '")';
+    if (node.kind === 277 /* SyntaxKind.ImportSpecifier */)
+        importText += '.' + identifierText;
+    c.error(errorNode, 1858 /* Diagnostics.X_0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation */, identifierText, importText);
+}
+function checkIsolatedModulesAlias(c, node, symbol, target, targetFlags) {
+    const verbatimModuleSyntax = c.compilerOptions.verbatimModuleSyntax === true;
+    const typeOnlyAlias = getTypeOnlyAliasDeclaration(c, symbol);
+    const isType = (targetFlags & 111551 /* SymbolFlags.Value */) === 0;
+    if (isType || typeOnlyAlias !== undefined) {
+        switch (node.kind) {
+            case 274 /* SyntaxKind.ImportClause */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */: {
+                if (verbatimModuleSyntax) {
+                    const message = node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+                        node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */
+                        ? 237 /* Diagnostics.An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabled */
+                        : isType
+                            ? 399 /* Diagnostics.X_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled */
+                            : 400 /* Diagnostics.X_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled */;
+                    const name = getText(getPropertyNameOrName(node));
+                    addTypeOnlyDeclarationRelatedInfo(c.error(node, message, name), isType ? undefined : typeOnlyAlias, name);
+                }
+                if (isType &&
+                    node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+                    hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                    c.error(node, 218 /* Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled */, getIsolatedModulesLikeFlagName(c));
+                break;
+            }
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                // `import type { A } from './a'; export { A }` is fine: one file shows the export is a type.
+                if (verbatimModuleSyntax ||
+                    typeOnlyAlias === undefined ||
+                    getSourceFileOfNode(typeOnlyAlias) !== getSourceFileOfNode(node)) {
+                    const name = getText(getPropertyNameOrName(node));
+                    const diagnostic = isType
+                        ? c.error(node, 159 /* Diagnostics.Re_exporting_a_type_when_0_is_enabled_requires_using_export_type */, getIsolatedModulesLikeFlagName(c))
+                        : c.error(node, 370 /* Diagnostics.X_0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_1_is_enabled */, name, getIsolatedModulesLikeFlagName(c));
+                    addTypeOnlyDeclarationRelatedInfo(diagnostic, isType ? undefined : typeOnlyAlias, name);
+                }
+                break;
+        }
+    }
+    if (verbatimModuleSyntax &&
+        node.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        !isInJSFile(node) &&
+        c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS)
+        c.error(node, verbatimModuleSyntaxErrorMessage(node));
+    else if (getEmitModuleKind(c.compilerOptions) === ModuleKind.Preserve &&
+        node.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.kind !== 261 /* SyntaxKind.VariableDeclaration */ &&
+        c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS)
+        // Under `--module preserve` ESM syntax emits as ESM, so it is an error in a file that is CommonJS (.cts, .cjs).
+        c.error(node, 242 /* Diagnostics.ECMAScript_module_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve */);
+    if (verbatimModuleSyntax &&
+        (targetFlags & 128 /* SymbolFlags.ConstEnum */) !== 0 &&
+        target.valueDeclaration !== undefined &&
+        (target.valueDeclaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+        c.error(node, 880 /* Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled */, getIsolatedModulesLikeFlagName(c));
+}
+/** The error for ESM syntax in a CommonJS file under `verbatimModuleSyntax`: shorter in a .cts or .cjs file. */
+function verbatimModuleSyntaxErrorMessage(node) {
+    return fileExtensionIsOneOf(getSourceFileOfNode(node).fileName, ['.cts', '.cjs'])
+        ? 235 /* Diagnostics.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax */
+        : 244 /* Diagnostics.ECMAScript_imports_and_exports_cannot_be_written_in_a_CommonJS_file_under_verbatimModuleSyntax_Adjust_the_type_field_in_the_nearest_package_json_to_make_this_file_an_ECMAScript_module_or_adjust_your_verbatimModuleSyntax_module_and_moduleResolution_settings_in_TypeScript */;
+}
+function isPartOfTypeOnlyImportOrExportDeclaration(node) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (isTypeOnlyImportOrExportDeclaration(current))
+            return true;
+    return false;
+}
+export function getIsolatedModulesLikeFlagName(c) {
+    return c.compilerOptions.verbatimModuleSyntax === true ? 'verbatimModuleSyntax' : 'isolatedModules';
+}
+/** The file a module declaration or import names. */
+export function getExternalModuleFileFromDeclaration(c, declaration) {
+    let specifier = undefined;
+    if (declaration.kind === 268 /* SyntaxKind.ModuleDeclaration */) {
+        const name = getName(declaration);
+        if (name !== undefined && name.kind === 10 /* SyntaxKind.StringLiteral */)
+            specifier = name;
+    }
+    else
+        specifier = getExternalModuleName(declaration);
+    if (specifier === undefined)
+        return undefined;
+    const moduleSymbol = resolveExternalModuleNameWorker(c, specifier, specifier, undefined, false, false);
+    if (moduleSymbol === undefined)
+        return undefined;
+    const file = getDeclarationOfKind(moduleSymbol, 307 /* SyntaxKind.SourceFile */);
+    return file === undefined ? undefined : file;
+}