tsc-ts 0.0.10 → 0.1.0

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

@@ -6,7 +6,7 @@
 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 { getExternalModuleName, isAmbientModule, isImportCall, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLiteralImportTypeNode, isRequireCall, isStringLiteralLike, isTypeOnly, nodeIsMissing, isImportPhaseMetaProperty, isSourcePhaseImport, isSourcePhaseImportCall, } 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';
@@ -15,30 +15,32 @@ import { getResolutionModeOverride, moduleKindName } from './program-utilities.j
 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 { getContainerFlags } from './binder.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 { createAnonymousType, getRegularTypeOfLiteralType, getStringLiteralType, isEmptyObjectType, 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 { getPropertyOfType, getPropertyOfTypeEx, getTypeOfPropertyOfType, 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 { checkExpressionCached, getResolvedSymbol } from './checker-expressions.js';
+import { isTypeAssignableTo, isTypeIdenticalTo, isTypeStrictSubtypeOf, 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 { getInstantiationExpressionType } from './checker-calls.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkTypeAssignableToAndOptionallyElaborate } from './checker-expressions.js';
 import { grammarErrorOnNode } from './checker-operators.js';
-import { declarationAt, declarationCount, getDeclarations, getSymbolId, setDeclarations, } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations, getSymbolId, setDeclarations, copyDeclarations, } from './symbol.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);
+export function resolveExternalModuleName(c, location, moduleReference, ignoreErrors, importAttributesType) {
+    return resolveExternalModuleNameWorker(c, location, moduleReference, ignoreErrors ? undefined : getCannotResolveModuleNameError(c, moduleReference), ignoreErrors, false, importAttributesType);
 }
 /** Node core modules suggest installing `@types/node`. */
 function getCannotResolveModuleNameError(c, moduleReference) {
@@ -47,26 +49,31 @@ function getCannotResolveModuleNameError(c, moduleReference) {
         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 */;
+            ? 737 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode */
+            : 746 /* Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig */;
     }
-    return 485 /* Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations */;
+    return 492 /* Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations */;
 }
-export function resolveExternalModuleNameWorker(c, location, moduleReference, moduleNotFoundError, ignoreErrors, isForAugmentation) {
+export function resolveExternalModuleNameWorker(c, location, moduleReference, moduleNotFoundError, ignoreErrors, isForAugmentation, importAttributesType) {
     if (moduleReference === undefined || !isStringLiteralLike(moduleReference))
         return undefined;
-    return resolveExternalModule(c, location, getText(moduleReference), moduleNotFoundError, ignoreErrors ? undefined : moduleReference, isForAugmentation);
+    // A source phase import loads no module declarations.
+    if (isSourcePhaseImport(moduleReference.parent))
+        return undefined;
+    return resolveExternalModule(c, location, getText(moduleReference), moduleNotFoundError, ignoreErrors ? undefined : moduleReference, isForAugmentation, importAttributesType);
 }
 /** A `resolveExternalModule` result that reported nothing, and the arguments it was computed for. */
 export class ModuleResolution {
     moduleReference;
     moduleNotFoundError;
     isForAugmentation;
+    importAttributesType;
     symbol;
-    constructor(moduleReference, moduleNotFoundError, isForAugmentation, symbol) {
+    constructor(moduleReference, moduleNotFoundError, isForAugmentation, importAttributesType, symbol) {
         this.moduleReference = moduleReference;
         this.moduleNotFoundError = moduleNotFoundError;
         this.isForAugmentation = isForAugmentation;
+        this.importAttributesType = importAttributesType;
         this.symbol = symbol;
     }
 }
@@ -76,7 +83,7 @@ export class ModuleResolution {
  * with the same result and the same diagnostics: a result that reported nothing is kept for the
  * specifier and returned to later calls from the same declaration (`sharesSpecifierContext`).
  */
-export function resolveExternalModule(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+export function resolveExternalModule(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation, importAttributesType) {
     // An augmentation merged later can give the resolved module a new merged symbol, so results are
     // kept only once every augmentation is merged.
     const shared = c.modulesMerged && errorNode !== undefined && sharesSpecifierContext(location, errorNode);
@@ -85,13 +92,14 @@ export function resolveExternalModule(c, location, moduleReference, moduleNotFou
         if (known !== undefined &&
             known.moduleReference === moduleReference &&
             known.moduleNotFoundError === moduleNotFoundError &&
-            known.isForAugmentation === isForAugmentation)
+            known.isForAugmentation === isForAugmentation &&
+            known.importAttributesType === importAttributesType)
             return known.symbol;
     }
     const reports = c.reports;
-    const symbol = resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation);
+    const symbol = resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation, importAttributesType ?? c.emptyObjectType);
     if (shared && c.reports === reports)
-        c.moduleResolutions.set(errorNode, new ModuleResolution(moduleReference, moduleNotFoundError, isForAugmentation, symbol));
+        c.moduleResolutions.set(errorNode, new ModuleResolution(moduleReference, moduleNotFoundError, isForAugmentation, importAttributesType, symbol));
     return symbol;
 }
 /**
@@ -103,24 +111,24 @@ export function resolveExternalModule(c, location, moduleReference, moduleNotFou
 function sharesSpecifierContext(location, errorNode) {
     const declaration = errorNode.parent;
     if (declaration === undefined ||
-        (declaration.kind !== 273 /* SyntaxKind.ImportDeclaration */ &&
-            declaration.kind !== 346 /* SyntaxKind.JSImportDeclaration */ &&
-            declaration.kind !== 279 /* SyntaxKind.ExportDeclaration */) ||
+        (declaration.kind !== 274 /* SyntaxKind.ImportDeclaration */ &&
+            declaration.kind !== 347 /* SyntaxKind.JSImportDeclaration */ &&
+            declaration.kind !== 280 /* SyntaxKind.ExportDeclaration */) ||
         getModuleSpecifier(declaration) !== errorNode)
         return false;
     for (let current = location; current !== undefined; current = current.parent)
         switch (current.kind) {
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 return current === declaration;
-            case 274 /* SyntaxKind.ImportClause */:
-            case 276 /* SyntaxKind.NamedImports */:
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 277 /* SyntaxKind.ImportSpecifier */:
-            case 280 /* SyntaxKind.NamedExports */:
-            case 281 /* SyntaxKind.NamespaceExport */:
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 275 /* SyntaxKind.ImportClause */:
+            case 277 /* SyntaxKind.NamedImports */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 281 /* SyntaxKind.NamedExports */:
+            case 282 /* SyntaxKind.NamespaceExport */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 break;
             default:
                 if (current !== errorNode)
@@ -128,12 +136,12 @@ function sharesSpecifierContext(location, errorNode) {
         }
     return false;
 }
-function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation, importAttributesType) {
     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);
+        c.error(errorNode, 1313 /* 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;
+        return tryResolvePatternAmbientModule(c, ambient, moduleReference, importAttributesType);
     const importingFile = getSourceFileOfNode(location);
     const contextSpecifier = getContextSpecifier(location);
     const mode = contextSpecifier !== undefined && isStringLiteralLike(contextSpecifier)
@@ -146,7 +154,7 @@ function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoun
         : undefined;
     const file = isResolved &&
         (resolutionDiagnostic === undefined ||
-            resolutionDiagnostic === 1307 /* Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set */)
+            resolutionDiagnostic === 1318 /* Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set */)
         ? c.host.getSourceFileForResolvedModule(resolved.resolvedFileName)
         : undefined;
     if (file !== undefined) {
@@ -162,30 +170,25 @@ function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoun
                     errorOnImplicitAnyModule(c, false, errorNode, mode, resolved, moduleReference);
                 checkSyncImportOfESModule(c, location, moduleReference, importingFile, file, errorNode);
             }
-            return getMergedSymbol(c, file.symbol);
+            return tryResolvePatternAmbientModule(c, getMergedSymbol(c, file.symbol), moduleReference, importAttributesType);
         }
+        const patternModule = tryResolvePatternAmbientModule(c, undefined, moduleReference, importAttributesType);
+        if (patternModule !== undefined)
+            return patternModule;
         if (errorNode !== undefined && moduleNotFoundError !== undefined && !isSideEffectImport(errorNode))
-            c.error(errorNode, 484 /* Diagnostics.File_0_is_not_a_module */, resolved.resolvedFileName);
+            c.error(errorNode, 491 /* 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);
+    const patternModule = tryResolvePatternAmbientModule(c, undefined, moduleReference, importAttributesType);
+    if (patternModule !== undefined)
+        return patternModule;
     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 */) {
+        resolutionDiagnostic === 1707 /* 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);
+            c.error(errorNode, 806 /* 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;
@@ -196,7 +199,7 @@ function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoun
         // 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);
+            c.error(errorNode, 1455 /* Diagnostics.Output_file_0_has_not_been_built_from_source_file_1 */, outputDts, resolved.resolvedFileName);
             return undefined;
         }
     }
@@ -206,7 +209,7 @@ function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoun
     }
     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);
+        c.error(errorNode, 871 /* 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) &&
@@ -214,9 +217,9 @@ function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoun
         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);
+            c.error(errorNode, 964 /* 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 */);
+            c.error(errorNode, 963 /* 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));
@@ -224,13 +227,76 @@ function resolveExternalModuleWorker(c, location, moduleReference, moduleNotFoun
         c.error(errorNode, moduleNotFoundError, moduleReference);
     return undefined;
 }
+/**
+ * The pattern ambient module `moduleReference` resolves to under `importAttributesType`, or
+ * `resolvedSymbol`. Without import attributes a module found by name or resolution wins. Among the
+ * patterns that match and accept the attributes, the one with the most specific attributes type wins,
+ * then the one with the longest prefix.
+ */
+function tryResolvePatternAmbientModule(c, resolvedSymbol, moduleReference, importAttributesType) {
+    if (resolvedSymbol !== undefined && isEmptyObjectType(c, importAttributesType))
+        return resolvedSymbol;
+    if (c.patternAmbientModules.length === 0)
+        return resolvedSymbol;
+    const candidates = [];
+    for (const pattern of c.patternAmbientModules)
+        if (pattern.matches(moduleReference) &&
+            isTypeAssignableTo(c, importAttributesType, getTypeOfModuleImportAttributes(c, pattern.symbol)))
+            candidates.push(pattern);
+    if (candidates.length === 0)
+        return resolvedSymbol;
+    let best = candidates[0];
+    if (candidates.length > 1) {
+        const bestTypeCandidates = [];
+        for (let i = 0; i < candidates.length; i++) {
+            const candidateType = getTypeOfModuleImportAttributes(c, candidates[i].symbol);
+            let isBest = true;
+            for (let j = 0; j < candidates.length && isBest; j++) {
+                const otherType = getTypeOfModuleImportAttributes(c, candidates[j].symbol);
+                if (i !== j &&
+                    isTypeStrictSubtypeOf(c, otherType, candidateType) &&
+                    !isTypeIdenticalTo(c, otherType, candidateType))
+                    isBest = false;
+            }
+            if (isBest)
+                bestTypeCandidates.push(candidates[i]);
+        }
+        // The pattern with the longest prefix wins.
+        best = bestTypeCandidates[0];
+        for (const pattern of bestTypeCandidates)
+            if (pattern.starIndex > best.starIndex)
+                best = pattern;
+    }
+    const merged = getMergedSymbol(c, best.symbol);
+    const augmentation = c.patternAmbientModuleAugmentations.get(moduleReference);
+    if (augmentation !== undefined && c.patternAmbientModuleAugmentationTargets.get(moduleReference) === merged)
+        return getMergedSymbol(c, augmentation);
+    return merged;
+}
+/** The import attributes type an ambient module declares, or the empty object type. */
+export function getTypeOfModuleImportAttributes(c, symbol) {
+    let result = c.moduleImportAttributesTypes.get(symbol);
+    if (result === undefined) {
+        result = c.emptyObjectType;
+        for (const declaration of getDeclarations(symbol))
+            if (declaration.kind === 269 /* SyntaxKind.ModuleDeclaration */ &&
+                getName(declaration).kind === 10 /* SyntaxKind.StringLiteral */) {
+                const attributes = declaration.attributes;
+                if (attributes !== undefined)
+                    result = getTypeFromTypeNode(c, attributes);
+                break;
+            }
+        c.moduleImportAttributesTypes.set(symbol, result);
+    }
+    return result;
+}
 /** 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))
+        (parent !== undefined && parent.kind === 269 /* SyntaxKind.ModuleDeclaration */ && getName(parent) === location))
         return location;
-    if (location.kind === 268 /* SyntaxKind.ModuleDeclaration */)
+    if (location.kind === 269 /* SyntaxKind.ModuleDeclaration */)
         return getName(location);
     if (isLiteralImportTypeNode(location))
         return location.argument.literal;
@@ -241,21 +307,21 @@ function getContextSpecifier(location) {
         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 */)
+        if (current.kind === 274 /* SyntaxKind.ImportDeclaration */ || current.kind === 347 /* SyntaxKind.JSImportDeclaration */)
             return getModuleSpecifier(current);
     for (let current = location; current !== undefined; current = current.parent)
-        if (current.kind === 279 /* SyntaxKind.ExportDeclaration */)
+        if (current.kind === 280 /* SyntaxKind.ExportDeclaration */)
             return getModuleSpecifier(current);
     for (let current = location; current !== undefined; current = current.parent)
-        if (current.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */) {
+        if (current.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */) {
             const reference = current.moduleReference;
-            return reference.kind === 284 /* SyntaxKind.ExternalModuleReference */ ? getExpression(reference) : undefined;
+            return reference.kind === 285 /* 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))
+    if (node.kind !== 262 /* SyntaxKind.VariableDeclaration */ || !isInJSFile(node))
         return undefined;
     const declaration = node;
     let initializer = declaration.initializer;
@@ -276,7 +342,7 @@ function checkResolvedModuleExtension(c, location, moduleReference, resolved, im
         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));
+            c.error(errorNode, 974 /* 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) &&
@@ -289,24 +355,24 @@ function checkResolvedModuleExtension(c, location, moduleReference, resolved, im
                     extension = candidate;
                     break;
                 }
-        c.error(errorNode, 1171 /* Diagnostics.An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled */, extension);
+        c.error(errorNode, 1178 /* 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 */: {
+            case 274 /* SyntaxKind.ImportDeclaration */: {
                 const clause = current.importClause;
                 if (clause !== undefined && !isTypeOnly(clause))
                     return true;
                 break;
             }
-            case 279 /* SyntaxKind.ExportDeclaration */:
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (!getIsTypeOnly(current))
                     return true;
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (isImportCall(current))
                     return true;
                 break;
@@ -355,7 +421,7 @@ function checkSyncImportOfESModule(c, location, moduleReference, importingFile,
     const moduleKind = getEmitModuleKind(c.compilerOptions);
     if (moduleKind !== ModuleKind.Node16 && moduleKind !== ModuleKind.Node18)
         return;
-    const importEquals = findAncestorOfKind(location, 272 /* SyntaxKind.ImportEqualsDeclaration */);
+    const importEquals = findAncestorOfKind(location, 273 /* SyntaxKind.ImportEqualsDeclaration */);
     const isSyncImport = (c.host.getDefaultResolutionModeForFile(importingFile) === ModuleKind.CommonJS && !isInImportCall(location)) ||
         importEquals !== undefined;
     if (!isSyncImport || c.host.getDefaultResolutionModeForFile(file) !== ModuleKind.ESNext)
@@ -364,7 +430,7 @@ function checkSyncImportOfESModule(c, location, moduleReference, importingFile,
     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);
+        c.error(errorNode, 384 /* 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;
@@ -373,16 +439,16 @@ function checkSyncImportOfESModule(c, location, moduleReference, importingFile,
         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 */) {
+    let message = 392 /* 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 === 274 /* 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 */;
+                454 /* 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 */)
+    else if (overrideHost !== undefined && overrideHost.kind === 207 /* SyntaxKind.ImportType */)
         message =
-            457 /* Diagnostics.Type_import_of_an_ECMAScript_module_from_a_CommonJS_module_must_have_a_resolution_mode_attribute */;
+            455 /* 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]));
@@ -402,19 +468,19 @@ function isInImportCall(node) {
 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 */:
+            case 207 /* SyntaxKind.ImportType */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
                 return current;
         }
     return undefined;
 }
 function hasResolutionModeOverride(node) {
     let attributes;
-    if (node.kind === 206 /* SyntaxKind.ImportType */)
+    if (node.kind === 207 /* SyntaxKind.ImportType */)
         attributes = node.attributes;
-    else if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+    else if (node.kind === 280 /* SyntaxKind.ExportDeclaration */)
         attributes = node.attributes;
     else
         attributes = node.attributes;
@@ -444,12 +510,12 @@ export function modeMismatchDetails(host, file) {
     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]);
+            ? new DiagnosticDetails(394 /* 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(395 /* 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 */, []);
+        ? new DiagnosticDetails(393 /* 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(396 /* 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) {
@@ -459,7 +525,7 @@ function errorOnImplicitAnyModule(c, isError, errorNode, mode, resolved, moduleR
     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 */;
+    const message = 1707 /* 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]));
@@ -481,18 +547,18 @@ export function moduleNotFoundDetails(host, file, moduleReference, mode, package
     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]);
+        return new DiagnosticDetails(1438 /* 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)]);
+        return new DiagnosticDetails(1730 /* 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)]);
+        return new DiagnosticDetails(1748 /* 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(1725 /* 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 */)
+    while (current !== undefined && current.kind !== 274 /* SyntaxKind.ImportDeclaration */)
         current = current.parent;
     return current !== undefined && current.importClause === undefined;
 }
@@ -521,14 +587,14 @@ export function resolveESModuleSymbol(c, moduleSymbol, node, moduleSpecifier) {
     if (symbol === undefined || moduleSymbol === undefined)
         return symbol;
     const referenceParent = moduleSpecifier.parent;
-    const namespaceImport = referenceParent.kind === 273 /* SyntaxKind.ImportDeclaration */ ? getNamespaceImport(referenceParent) : undefined;
+    const namespaceImport = referenceParent.kind === 274 /* 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);
+    const defaultOnlyType = getTypeWithSyntheticDefaultOnly(c, type, symbol, moduleSymbol, reference, getImportAttributesTypeForModuleSpecifier(c, reference));
     if (defaultOnlyType !== undefined)
         return cloneTypeAsModuleType(c, symbol, defaultOnlyType);
     if (hasSignatures(c, type) || getPropertyOfTypeEx(c, type, "default" /* InternalSymbolName.Default */, true, false) !== undefined) {
@@ -542,7 +608,7 @@ export function resolveESModuleSymbol(c, moduleSymbol, node, moduleSpecifier) {
 function getNamespaceImport(declaration) {
     const clause = declaration.importClause;
     const bindings = clause?.namedBindings;
-    return bindings !== undefined && bindings.kind === 275 /* SyntaxKind.NamespaceImport */ ? bindings : undefined;
+    return bindings !== undefined && bindings.kind === 276 /* SyntaxKind.NamespaceImport */ ? bindings : undefined;
 }
 function hasSignatures(c, type) {
     return (getSignaturesOfStructuredType(c, type, 0 /* SignatureKind.Call */).length > 0 ||
@@ -552,13 +618,13 @@ function hasSignatures(c, type) {
  * 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) {
+function isOnlyImportableAsDefault(c, usage, resolvedModule, importAttributesType) {
     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 moduleSymbol = resolvedModule ?? resolveExternalModuleName(c, usage, usage, true, importAttributesType);
     const targetFile = moduleSymbol !== undefined ? getSourceFileOfModuleSymbol(moduleSymbol) : undefined;
     return (targetFile !== undefined &&
         (isJsonSourceFile(targetFile) ||
@@ -576,8 +642,8 @@ function getSourceFileOfModuleSymbol(symbol) {
     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))
+function getTypeWithSyntheticDefaultOnly(c, type, symbol, originalSymbol, moduleSpecifier, importAttributesType) {
+    if (!isOnlyImportableAsDefault(c, moduleSpecifier, undefined, importAttributesType) || isErrorType(c, type))
         return undefined;
     const key = 'defaultOnly:' + type.id;
     const cached = c.moduleTypeCache.get(key);
@@ -599,6 +665,7 @@ function getTypeWithSyntheticDefaultImportType(c, type, symbol, originalSymbol,
     let result = type;
     if (canHaveSyntheticDefault(c, file, originalSymbol, false, moduleSpecifier)) {
         const anonymousSymbol = c.newSymbol(2048 /* SymbolFlags.TypeLiteral */, "\uFFFEtype" /* InternalSymbolName.Type */);
+        copyDeclarations(anonymousSymbol, originalSymbol);
         const defaultContainingObject = createDefaultPropertyWrapperForModule(c, symbol, originalSymbol, anonymousSymbol);
         c.symbolTypes.set(getSymbolId(anonymousSymbol), defaultContainingObject);
         result = isValidSpreadType(c, type)
@@ -617,6 +684,10 @@ function createDefaultPropertyWrapperForModule(c, symbol, originalSymbol, anonym
     links.aliasTarget = resolveSymbol(c, symbol);
     const members = new Map();
     members.set("default" /* InternalSymbolName.Default */, defaultSymbol);
+    if (anonymousSymbol === undefined && originalSymbol !== undefined) {
+        anonymousSymbol = c.newSymbol(4096 /* SymbolFlags.ObjectLiteral */, "\uFFFEobject" /* InternalSymbolName.Object */);
+        copyDeclarations(anonymousSymbol, originalSymbol);
+    }
     return createAnonymousType(c, anonymousSymbol, members, [], [], []);
 }
 function cloneTypeAsModuleType(c, symbol, moduleType) {
@@ -636,12 +707,12 @@ function getSourceFileDeclaration(symbol) {
     if (symbol === undefined)
         return undefined;
     for (const d of getDeclarations(symbol))
-        if (d.kind === 307 /* SyntaxKind.SourceFile */)
+        if (d.kind === 308 /* 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) {
+export function getEmitSyntaxForModuleSpecifierExpression(c, usage) {
     return isStringLiteralLike(usage)
         ? c.host.getEmitSyntaxForUsageLocation(getSourceFileOfNode(usage), usage)
         : ModuleKind.None;
@@ -683,17 +754,17 @@ function hasSyntacticDefault(symbol) {
     return false;
 }
 function isSyntacticDefault(node) {
-    return ((node.kind === 278 /* SyntaxKind.ExportAssignment */ && !node.isExportEquals) ||
+    return ((node.kind === 279 /* SyntaxKind.ExportAssignment */ && !node.isExportEquals) ||
         hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */) ||
-        node.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
-        node.kind === 281 /* SyntaxKind.NamespaceExport */);
+        node.kind === 283 /* SyntaxKind.ExportSpecifier */ ||
+        node.kind === 282 /* 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;
+    return d !== undefined && d.kind === 269 /* SyntaxKind.ModuleDeclaration */ && d.body === undefined;
 }
 // ---- Alias targets
 /** The symbol an alias declaration refers to, without resolving further aliases. */
@@ -701,38 +772,41 @@ export function getTargetOfAliasDeclaration(c, node) {
     if (node === undefined)
         return undefined;
     switch (node.kind) {
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
             return getTargetOfImportEqualsDeclaration(c, node);
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return getTargetOfImportClause(c, node);
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             return getTargetOfNamespaceImport(c, node);
-        case 281 /* SyntaxKind.NamespaceExport */:
+        case 282 /* SyntaxKind.NamespaceExport */:
             return getTargetOfNamespaceExport(c, node);
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 209 /* SyntaxKind.BindingElement */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 210 /* SyntaxKind.BindingElement */:
             return getTargetOfImportSpecifier(c, node);
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return getTargetOfExportSpecifier(c, node, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true);
-        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+            // An export assignment in a namespace is an error, and its expression is not resolved.
+            if (isContainedByNamespace(node))
+                return undefined;
             return withTypeOnlyMark(c, node, getTargetOfAliasLikeExpression(c, getExpression(node)));
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return withTypeOnlyMark(c, node, getTargetOfAliasLikeExpression(c, node.right));
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */: {
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */: {
             const resolved = resolveExternalModuleSymbol(c, getSymbol(node.parent), true);
             markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
             return resolved;
         }
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             return resolveEntityName(c, getName(node), 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, true, true, undefined);
-        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
             return getTargetOfAliasLikeExpression(c, getInitializer(node));
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */: {
             const parent = node.parent;
             if (parent !== undefined &&
-                parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+                parent.kind === 228 /* SyntaxKind.BinaryExpression */ &&
                 parent.left === node &&
                 parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */)
                 return getTargetOfAliasLikeExpression(c, parent.right);
@@ -746,11 +820,11 @@ function withTypeOnlyMark(c, node, resolved) {
     return resolved;
 }
 function getTargetOfImportEqualsDeclaration(c, node) {
-    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */ || isExternalModuleImportEquals(node)) {
+    if (node.kind === 262 /* SyntaxKind.VariableDeclaration */ || isExternalModuleImportEquals(node)) {
         const moduleReference = isVariableDeclarationInitializedToRequire(node)
             ? getInitializer(node).arguments.nodes[0]
             : getExpression(node.moduleReference);
-        const immediate = resolveExternalModuleName(c, node, moduleReference, false);
+        const immediate = resolveExternalModuleName(c, node, moduleReference, false, undefined);
         const resolved = resolveExternalModuleSymbol(c, immediate, true);
         const moduleKind = getEmitModuleKind(c.compilerOptions);
         if (resolved !== undefined && moduleKind >= ModuleKind.Node20 && moduleKind <= ModuleKind.NodeNext) {
@@ -766,8 +840,8 @@ function getTargetOfImportEqualsDeclaration(c, node) {
     return resolved;
 }
 function isExternalModuleImportEquals(node) {
-    return (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
-        node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */);
+    return (node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */);
 }
 /**
  * Resolves the entity name of `import a = b.c`: `b` alone or the left part of a longer name is a
@@ -776,10 +850,10 @@ function isExternalModuleImportEquals(node) {
 export function getSymbolOfPartOfRightHandSideOfImportEquals(c, entityName) {
     if (entityName.kind === 79 /* SyntaxKind.Identifier */ &&
         entityName.parent !== undefined &&
-        entityName.parent.kind === 167 /* SyntaxKind.QualifiedName */ &&
+        entityName.parent.kind === 168 /* SyntaxKind.QualifiedName */ &&
         entityName.parent.right === entityName)
         entityName = entityName.parent;
-    if (entityName.kind === 79 /* SyntaxKind.Identifier */ || entityName.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+    if (entityName.kind === 79 /* SyntaxKind.Identifier */ || entityName.parent.kind === 168 /* 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);
 }
@@ -788,28 +862,40 @@ function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(c, node) {
     for (;;) {
         const typeOnlyDeclaration = getTypeOnlyDeclarationOfEntityName(c, name);
         if (typeOnlyDeclaration !== undefined) {
-            const isExport = typeOnlyDeclaration.kind === 282 /* SyntaxKind.ExportSpecifier */ ||
-                typeOnlyDeclaration.kind === 279 /* SyntaxKind.ExportDeclaration */;
+            const isExport = typeOnlyDeclaration.kind === 283 /* SyntaxKind.ExportSpecifier */ ||
+                typeOnlyDeclaration.kind === 280 /* 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));
+            const typeOnlyName = typeOnlyDeclaration.kind === 280 /* 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 */)
+        if (name.kind !== 168 /* SyntaxKind.QualifiedName */)
             return;
         name = name.left;
     }
 }
 function getTypeOnlyDeclarationOfEntityName(c, name) {
-    if (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 167 /* SyntaxKind.QualifiedName */)
+    if (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 168 /* 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);
+    // `import source x from "m"` binds a module source object, not the module's default export.
+    if (node.phaseModifier === 167 /* SyntaxKind.SourceKeyword */) {
+        const alias = getSymbolOfDeclaration(c, node);
+        const links = c.symbolLinks(alias);
+        if (links.immediateTarget === undefined) {
+            const symbol = c.newSymbol(1 /* SymbolFlags.FunctionScopedVariable */, getText(node.name));
+            setDeclarations(symbol, getDeclarations(alias).slice());
+            c.symbolTypes.set(getSymbolId(symbol), getGlobalAbstractModuleSourceType(c));
+            links.immediateTarget = symbol;
+        }
+        return links.immediateTarget;
+    }
+    const moduleSymbol = resolveExternalModuleName(c, node, getModuleSpecifier(node.parent), false, getTypeFromImportAttributes(c, getImportAttributes(node.parent)));
     return moduleSymbol !== undefined ? getTargetOfModuleDefault(c, moduleSymbol, node, true) : undefined;
 }
 function getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias) {
@@ -820,13 +906,20 @@ function getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias) {
         : resolveExportByName(c, moduleSymbol, "default" /* InternalSymbolName.Default */, node, dontResolveAlias);
     if (specifier === undefined)
         return exportDefaultSymbol;
-    const hasDefaultOnly = isOnlyImportableAsDefault(c, specifier, moduleSymbol);
+    let attributes;
+    if (node.kind === 275 /* SyntaxKind.ImportClause */)
+        attributes = getImportAttributes(node.parent);
+    else if (node.kind === 278 /* SyntaxKind.ImportSpecifier */)
+        attributes = getImportAttributes(node.parent.parent.parent);
+    else if (node.kind === 283 /* SyntaxKind.ExportSpecifier */)
+        attributes = getImportAttributes(node.parent.parent);
+    const hasDefaultOnly = isOnlyImportableAsDefault(c, specifier, moduleSymbol, getTypeFromImportAttributes(c, attributes));
     const hasSyntheticDefault = canHaveSyntheticDefault(c, file, moduleSymbol, dontResolveAlias, specifier);
     if (exportDefaultSymbol === undefined && !hasSyntheticDefault && !hasDefaultOnly) {
-        if (node.kind === 274 /* SyntaxKind.ImportClause */)
+        if (node.kind === 275 /* SyntaxKind.ImportClause */)
             reportNonDefaultExport(c, moduleSymbol, node);
         else {
-            const name = node.kind === 277 /* SyntaxKind.ImportSpecifier */ || node.kind === 282 /* SyntaxKind.ExportSpecifier */
+            const name = node.kind === 278 /* SyntaxKind.ImportSpecifier */ || node.kind === 283 /* SyntaxKind.ExportSpecifier */
                 ? getPropertyNameOrName(node)
                 : getName(node);
             errorNoModuleMemberSymbol(c, moduleSymbol, moduleSymbol, node, name);
@@ -845,7 +938,7 @@ function getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias) {
 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));
+        c.error(node, 764 /* 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));
@@ -854,9 +947,9 @@ function reportNonDefaultExport(c, moduleSymbol, node) {
         return;
     for (const d of getDeclarations(exportStar)) {
         const specifier = getModuleSpecifier(d);
-        if (d.kind !== 279 /* SyntaxKind.ExportDeclaration */ || specifier === undefined)
+        if (d.kind !== 280 /* SyntaxKind.ExportDeclaration */ || specifier === undefined)
             continue;
-        const resolved = resolveExternalModuleName(c, d, specifier, false);
+        const resolved = resolveExternalModuleName(c, d, specifier, false, getTypeFromImportAttributes(c, getImportAttributes(d)));
         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;
@@ -874,7 +967,7 @@ function resolveExportByName(c, moduleSymbol, name, sourceNode, dontResolveAlias
 }
 function getTargetOfNamespaceImport(c, node) {
     const moduleSpecifier = getModuleSpecifierForImportOrExport(node);
-    const immediate = resolveExternalModuleName(c, node, moduleSpecifier, false);
+    const immediate = resolveExternalModuleName(c, node, moduleSpecifier, false, getTypeFromImportAttributes(c, getImportAttributes(node.parent.parent)));
     const resolved = resolveESModuleSymbol(c, immediate, node, moduleSpecifier);
     markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
     return resolved;
@@ -883,22 +976,22 @@ function getTargetOfNamespaceExport(c, node) {
     const moduleSpecifier = getModuleSpecifierForImportOrExport(node);
     if (moduleSpecifier === undefined)
         return undefined;
-    const immediate = resolveExternalModuleName(c, node, moduleSpecifier, false);
+    const immediate = resolveExternalModuleName(c, node, moduleSpecifier, false, getTypeFromImportAttributes(c, getImportAttributes(node.parent)));
     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)) {
+    if (node.kind === 278 /* SyntaxKind.ImportSpecifier */ && moduleExportNameIsDefault(name)) {
         const specifier = getModuleSpecifierForImportOrExport(node);
         if (specifier !== undefined) {
-            const moduleSymbol = resolveExternalModuleName(c, node, specifier, false);
+            const moduleSymbol = resolveExternalModuleName(c, node, specifier, false, getTypeFromImportAttributes(c, getImportAttributes(node.parent.parent.parent)));
             if (moduleSymbol !== undefined)
                 return getTargetOfModuleDefault(c, moduleSymbol, node, true);
         }
     }
-    const root = node.kind === 209 /* SyntaxKind.BindingElement */ ? getRootDeclaration(node) : node.parent.parent.parent;
+    const root = node.kind === 210 /* SyntaxKind.BindingElement */ ? getRootDeclaration(node) : node.parent.parent.parent;
     const resolved = getExternalModuleMember(c, root, node, true);
     markSymbolOfAliasDeclarationIfTypeOnly(c, node, undefined);
     return resolved;
@@ -908,8 +1001,9 @@ 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);
+    const importAttributesType = getTypeFromImportAttributes(c, getImportAttributes(node));
+    const moduleSymbol = resolveExternalModuleName(c, node, moduleSpecifier, false, importAttributesType);
+    const name = specifier.kind === 213 /* SyntaxKind.PropertyAccessExpression */ ? getName(specifier) : getPropertyNameOrName(specifier);
     if (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 10 /* SyntaxKind.StringLiteral */)
         return undefined;
     const nameText = getText(name);
@@ -932,7 +1026,7 @@ export function getExternalModuleMember(c, node, specifier, dontResolveAlias) {
     let symbolFromModule = getExportOfModule(c, exportEquals ? moduleSymbol : targetSymbol, nameText, specifier, dontResolveAlias);
     if (symbolFromModule === undefined &&
         nameText === "default" /* InternalSymbolName.Default */ &&
-        (isOnlyImportableAsDefault(c, moduleSpecifier, moduleSymbol) ||
+        (isOnlyImportableAsDefault(c, moduleSpecifier, moduleSymbol, importAttributesType) ||
             canHaveSyntheticDefault(c, getSourceFileDeclaration(moduleSymbol), moduleSymbol, dontResolveAlias, moduleSpecifier)))
         symbolFromModule =
             resolveExternalModuleSymbol(c, moduleSymbol, dontResolveAlias) ??
@@ -942,10 +1036,10 @@ export function getExternalModuleMember(c, node, specifier, dontResolveAlias) {
         : symbolFromVariable === undefined
             ? symbolFromModule
             : combineValueAndTypeSymbols(c, symbolFromVariable, symbolFromModule);
-    if ((specifier.kind === 277 /* SyntaxKind.ImportSpecifier */ || specifier.kind === 282 /* SyntaxKind.ExportSpecifier */) &&
+    if ((specifier.kind === 278 /* SyntaxKind.ImportSpecifier */ || specifier.kind === 283 /* 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)));
+        isOnlyImportableAsDefault(c, moduleSpecifier, moduleSymbol, importAttributesType))
+        c.error(name, 457 /* 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;
@@ -998,13 +1092,13 @@ function errorNoModuleMemberSymbol(c, moduleSymbol, targetSymbol, node, name) {
         : 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);
+        const diagnostic = c.error(name, 863 /* 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]));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(suggestion.valueDeclaration, 867 /* 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);
+        c.error(name, 765 /* 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);
@@ -1013,7 +1107,7 @@ function reportNonExportedMember(c, name, declarationName, moduleSymbol, moduleN
     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);
+        c.error(name, 490 /* Diagnostics.Module_0_has_no_exported_member_1 */, moduleName, declarationName);
         return;
     }
     const exports = moduleSymbol.exports;
@@ -1022,7 +1116,7 @@ function reportNonExportedMember(c, name, declarationName, moduleSymbol, moduleN
         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);
+            c.error(name, 490 /* Diagnostics.Module_0_has_no_exported_member_1 */, moduleName, declarationName);
         return;
     }
     let exportedSymbol;
@@ -1033,10 +1127,10 @@ function reportNonExportedMember(c, name, declarationName, moduleSymbol, moduleN
                 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);
+        ? c.error(name, 633 /* Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2 */, moduleName, declarationName, symbolToString(c, exportedSymbol))
+        : c.error(name, 632 /* Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported */, moduleName, declarationName);
     for (let i = 0; i < declarationCount(localSymbol); i++)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(declarationAt(localSymbol, i), i === 0 ? 860 /* Diagnostics.X_0_is_declared_here */ : 1357 /* Diagnostics.X_and_here */, [declarationName]));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(declarationAt(localSymbol, i), i === 0 ? 867 /* Diagnostics.X_0_is_declared_here */ : 1368 /* Diagnostics.X_and_here */, [declarationName]));
 }
 function isSameReference(c, s1, s2) {
     return (getMergedSymbol(c, resolveSymbol(c, getMergedSymbol(c, s1))) ===
@@ -1044,18 +1138,18 @@ function isSameReference(c, s1, 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);
+        c.error(name, 750 /* 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);
+        c.error(name, 752 /* 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);
+        c.error(name, 767 /* 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);
+            const moduleSymbol = resolveExternalModuleName(c, node, specifier, false, getTypeFromImportAttributes(c, getImportAttributes(node.parent.parent)));
             if (moduleSymbol !== undefined)
                 return getTargetOfModuleDefault(c, moduleSymbol, node, dontResolveAlias);
         }
@@ -1070,7 +1164,7 @@ export function getTargetOfExportSpecifier(c, node, meaning, dontResolveAlias) {
     return resolved;
 }
 function getTargetOfAliasLikeExpression(c, expression) {
-    if (expression.kind === 232 /* SyntaxKind.ClassExpression */)
+    if (expression.kind === 233 /* SyntaxKind.ClassExpression */)
         return checkExpressionCached(c, expression).symbol;
     if (!isEntityNameOrEntityNameExpression(expression))
         return undefined;
@@ -1083,9 +1177,9 @@ function getTargetOfAliasLikeExpression(c, expression) {
 function isEntityNameOrEntityNameExpression(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return true;
-    if (node.kind === 167 /* SyntaxKind.QualifiedName */)
+    if (node.kind === 168 /* SyntaxKind.QualifiedName */)
         return true;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const name = getName(node);
         return (name !== undefined &&
             name.kind === 79 /* SyntaxKind.Identifier */ &&
@@ -1098,25 +1192,25 @@ function getPropertyNameOrName(node) {
 }
 function getModuleSpecifierForImportOrExport(node) {
     switch (node.kind) {
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return getModuleSpecifierOfDeclaration(node.parent);
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */: {
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */: {
             const reference = node.moduleReference;
-            return reference.kind === 284 /* SyntaxKind.ExternalModuleReference */ ? getExpression(reference) : undefined;
+            return reference.kind === 285 /* SyntaxKind.ExternalModuleReference */ ? getExpression(reference) : undefined;
         }
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             return getModuleSpecifierOfDeclaration(node.parent.parent);
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             return getModuleSpecifierOfDeclaration(node.parent.parent.parent);
-        case 281 /* SyntaxKind.NamespaceExport */:
+        case 282 /* SyntaxKind.NamespaceExport */:
             return getModuleSpecifierOfDeclaration(node.parent);
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return getModuleSpecifierOfDeclaration(node.parent.parent);
     }
     return undefined;
 }
 function getModuleSpecifierOfDeclaration(node) {
-    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+    if (node.kind === 280 /* SyntaxKind.ExportDeclaration */)
         return node.moduleSpecifier;
     return getModuleSpecifier(node);
 }
@@ -1124,27 +1218,27 @@ function getModuleSpecifierOfDeclaration(node) {
 /** Whether the declaration itself is written `import type` or `export type`. */
 export function isTypeOnlyImportOrExportDeclaration(node) {
     switch (node.kind) {
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             return getIsTypeOnly(node) || isTypeOnlyImportClause(node.parent.parent);
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             return isTypeOnlyImportClause(node.parent);
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return isTypeOnlyImportClause(node);
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             return getIsTypeOnly(node);
-        case 282 /* SyntaxKind.ExportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
             return getIsTypeOnly(node) || getIsTypeOnly(node.parent.parent);
-        case 279 /* SyntaxKind.ExportDeclaration */: {
+        case 280 /* SyntaxKind.ExportDeclaration */: {
             const declaration = node;
             return (declaration.isTypeOnly && declaration.moduleSpecifier !== undefined && declaration.exportClause === undefined);
         }
-        case 281 /* SyntaxKind.NamespaceExport */:
+        case 282 /* SyntaxKind.NamespaceExport */:
             return getIsTypeOnly(node.parent);
     }
     return false;
 }
 function isTypeOnlyImportClause(node) {
-    return node.kind === 274 /* SyntaxKind.ImportClause */ && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
+    return node.kind === 275 /* SyntaxKind.ImportClause */ && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
 }
 /**
  * Marks an alias declared `import type`/`export type`, or reached through a type-only `export *`,
@@ -1170,19 +1264,19 @@ function markSymbolOfAliasDeclarationIfTypeOnly(c, aliasDeclaration, exportStarD
 /** 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 */)
+    while (current.parent !== undefined && current.parent.kind === 168 /* 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 */:
+        case 275 /* SyntaxKind.ImportClause */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 282 /* SyntaxKind.NamespaceExport */:
             markSymbolOfAliasDeclarationIfTypeOnly(c, parent, undefined);
     }
 }
@@ -1217,9 +1311,9 @@ export function getTypeOnlyAliasDeclarationOfMeaning(c, symbol, meaning) {
 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 */;
+    const isExport = typeOnlyDeclaration.kind === 283 /* SyntaxKind.ExportSpecifier */ ||
+        typeOnlyDeclaration.kind === 280 /* SyntaxKind.ExportDeclaration */ ||
+        typeOnlyDeclaration.kind === 282 /* 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. */
@@ -1231,9 +1325,9 @@ export function checkTypeOnlyAliasUse(c, location, result, name) {
     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 isExport = typeOnlyDeclaration.kind === 283 /* SyntaxKind.ExportSpecifier */ ||
+        typeOnlyDeclaration.kind === 280 /* SyntaxKind.ExportDeclaration */ ||
+        typeOnlyDeclaration.kind === 282 /* 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);
@@ -1250,26 +1344,26 @@ 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 */)
+    while (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || parent.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */)
         parent = parent.parent;
-    return (parent.kind === 299 /* SyntaxKind.HeritageClause */ &&
+    return (parent.kind === 300 /* SyntaxKind.HeritageClause */ &&
         (parent.token === 118 /* SyntaxKind.ImplementsKeyword */ ||
-            parent.parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */));
+            parent.parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */));
 }
 function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
     let current = node;
-    while (current.kind === 79 /* SyntaxKind.Identifier */ || current.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    while (current.kind === 79 /* SyntaxKind.Identifier */ || current.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         current = current.parent;
-    if (current.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+    if (current.kind !== 169 /* 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 */;
+    return container === 266 /* SyntaxKind.InterfaceDeclaration */ || container === 189 /* SyntaxKind.TypeLiteral */;
 }
 function isShorthandPropertyNameUseSite(useSite) {
     return (useSite.kind === 79 /* SyntaxKind.Identifier */ &&
-        useSite.parent.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ &&
+        useSite.parent.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */ &&
         getName(useSite.parent) === useSite);
 }
 // ---- Referenced aliases
@@ -1298,14 +1392,14 @@ function shouldMarkIdentifierAliasReferenced(node) {
     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)
+    if (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && getExpression(parent) === node)
         return false;
     // Names of type-only exports aren't emitted.
-    if (parent.kind === 282 /* SyntaxKind.ExportSpecifier */ && getIsTypeOnly(parent))
+    if (parent.kind === 283 /* SyntaxKind.ExportSpecifier */ && getIsTypeOnly(parent))
         return false;
     const greatGrandparent = parent.parent?.parent;
     return !(greatGrandparent !== undefined &&
-        greatGrandparent.kind === 279 /* SyntaxKind.ExportDeclaration */ &&
+        greatGrandparent.kind === 280 /* SyntaxKind.ExportDeclaration */ &&
         getIsTypeOnly(greatGrandparent));
 }
 /**
@@ -1317,7 +1411,7 @@ export function markPropertyAliasReferenced(c, location, prop, leftType) {
         return;
     if ((location.flags & 8388608 /* NodeFlags.Ambient */) !== 0 || isPartOfImportEqualsModuleReference(location))
         return;
-    const left = location.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ? getExpression(location) : location.left;
+    const left = location.kind === 213 /* SyntaxKind.PropertyAccessExpression */ ? getExpression(location) : location.left;
     if (left.kind !== 79 /* SyntaxKind.Identifier */ || getText(left) === 'this')
         return;
     const parentSymbol = getResolvedSymbol(c, left);
@@ -1332,13 +1426,13 @@ export function markPropertyAliasReferenced(c, location, prop, leftType) {
     }
     if (prop !== undefined &&
         (isConstEnumOrConstEnumOnlyModule(prop) ||
-            ((prop.flags & 8 /* SymbolFlags.EnumMember */) !== 0 && location.parent.kind === 306 /* SyntaxKind.EnumMember */)))
+            ((prop.flags & 8 /* SymbolFlags.EnumMember */) !== 0 && location.parent.kind === 307 /* SyntaxKind.EnumMember */)))
         return;
     markAliasReferenced(c, parentSymbol, location);
 }
 function isPartOfImportEqualsModuleReference(location) {
     let importEquals = location;
-    while (importEquals !== undefined && importEquals.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */)
+    while (importEquals !== undefined && importEquals.kind !== 273 /* SyntaxKind.ImportEqualsDeclaration */)
         importEquals = importEquals.parent;
     if (importEquals === undefined)
         return false;
@@ -1378,8 +1472,8 @@ function markAliasSymbolAsReferenced(c, symbol) {
     links.aliasReferenced = true;
     const node = getDeclarationOfAliasSymbol(symbol);
     if (node !== undefined &&
-        node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
-        node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */ &&
+        node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.moduleReference.kind !== 285 /* SyntaxKind.ExternalModuleReference */ &&
         (getSymbolFlags(c, resolveSymbol(c, symbol)) & 111551 /* SymbolFlags.Value */) !== 0)
         markIdentifierAliasReferenced(c, getFirstIdentifierOfEntityName(node.moduleReference));
 }
@@ -1416,9 +1510,9 @@ function isExportOrExportExpression(location) {
         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 (parent.kind === 279 /* SyntaxKind.ExportAssignment */)
+            return (getExpression(parent) === n && isEntityNameOrEntityNameExpression(n) && n.kind !== 168 /* SyntaxKind.QualifiedName */);
+        if (parent.kind === 283 /* SyntaxKind.ExportSpecifier */) {
             if (getName(parent) === n || getPropertyName(parent) === n)
                 return true;
         }
@@ -1510,7 +1604,7 @@ class ExportCollector {
             const lookupTable = new Map();
             for (const node of getDeclarations(exportStars)) {
                 const specifier = node.moduleSpecifier;
-                const resolved = resolveExternalModuleName(this.c, node, specifier, false);
+                const resolved = resolveExternalModuleName(this.c, node, specifier, false, getTypeFromImportAttributes(this.c, getImportAttributes(node)));
                 const exported = this.visit(resolved, node, isTypeOnly || getIsTypeOnly(node));
                 this.extendExportSymbols(nested, exported, lookupTable, node);
             }
@@ -1519,7 +1613,7 @@ class ExportCollector {
                 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.c.error(node, 493 /* 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);
         }
@@ -1567,7 +1661,7 @@ export function getTypeFromImportTypeNode(c, node) {
     }
     const targetMeaning = importType.isTypeOf ? 111551 /* SymbolFlags.Value */ : 788968 /* SymbolFlags.Type */;
     const literal = importType.argument.literal;
-    const innerModuleSymbol = resolveExternalModuleName(c, node, literal, false);
+    const innerModuleSymbol = resolveExternalModuleName(c, node, literal, false, getTypeFromImportAttributes(c, importType.attributes));
     if (innerModuleSymbol === undefined) {
         c.resolvedSymbols.set(node.id, c.unknownSymbol);
         c.resolvedTypes.set(node.id, c.errorType);
@@ -1587,7 +1681,7 @@ export function getTypeFromImportTypeNode(c, node) {
                 ? 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.error(current, 833 /* 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);
             }
@@ -1619,9 +1713,9 @@ function getIdentifierChain(node) {
 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.
+    // A value's type comes from the alias, which caches it, instantiated with the node's type arguments.
     if (meaning === 111551 /* SymbolFlags.Value */)
-        return getTypeOfSymbol(c, symbol);
+        return getInstantiationExpressionType(c, getTypeOfSymbol(c, symbol), node);
     return getTypeReferenceType(c, node, resolvedSymbol);
 }
 /** `import(specifier, options)`: a promise of the module namespace. */
@@ -1636,49 +1730,57 @@ export function checkImportCallExpression(c, node) {
     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));
+        c.error(specifier, 1726 /* Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0 */, typeToString(c, specifierType));
+    let importAttributesType;
     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 */)
+        if (args[1].kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
             for (const property of args[1].properties.nodes) {
                 const name = getName(property);
-                if (property.kind === 303 /* SyntaxKind.PropertyAssignment */ &&
+                if (property.kind === 304 /* 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 */);
+                    c.error(name, 1007 /* Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert */);
                     break;
                 }
             }
+        importAttributesType = getTypeOfPropertyOfType(c, optionsType, 'with');
     }
-    const moduleSymbol = resolveExternalModuleName(c, node, specifier, false);
+    if (isSourcePhaseImportCall(node))
+        return createPromiseReturnType(c, node, getGlobalAbstractModuleSourceType(c));
+    const moduleSymbol = resolveExternalModuleName(c, node, specifier, false, importAttributesType);
     if (moduleSymbol !== undefined) {
         const esModuleSymbol = resolveExternalModuleSymbol(c, moduleSymbol, true);
         if (esModuleSymbol !== undefined)
-            return createPromiseReturnType(c, node, getTypeWithSyntheticDefaultOnly(c, getTypeOfSymbol(c, esModuleSymbol), esModuleSymbol, moduleSymbol, specifier) ??
+            return createPromiseReturnType(c, node, getTypeWithSyntheticDefaultOnly(c, getTypeOfSymbol(c, esModuleSymbol), esModuleSymbol, moduleSymbol, specifier, importAttributesType) ??
                 getTypeWithSyntheticDefaultImportType(c, getTypeOfSymbol(c, esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
     }
     return createPromiseReturnType(c, node, c.anyType);
 }
+/** `AbstractModuleSource`, the type of a source phase import's binding (lib.esnext.modulesource). */
+function getGlobalAbstractModuleSourceType(c) {
+    return getCachedGlobalType(c, 'AbstractModuleSource', 0, true);
+}
 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 */);
+    c.error(node, 850 /* 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 */))
+    if (name === undefined || (name.kind !== 79 /* SyntaxKind.Identifier */ && name.kind !== 168 /* 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 */)
+    if (name.kind !== 168 /* SyntaxKind.QualifiedName */)
         return undefined;
     const left = resolveJSDocMemberName(c, name.left);
     if (left === undefined)
@@ -1689,11 +1791,11 @@ export function resolveJSDocMemberName(c, name) {
         if (prototype !== undefined)
             type = getTypeOfSymbol(c, prototype);
     }
-    return getPropertyOfType(c, type ?? getDeclaredTypeOfSymbol(c, left), name.right.text);
+    return getPropertyOfType(c, type ?? getDeclaredTypeOfSymbol(c, left), getText(name.right));
 }
 export function getHostSignatureFromJSDoc(node) {
     let current = node;
-    while (current !== undefined && current.kind !== 315 /* SyntaxKind.JSDoc */)
+    while (current !== undefined && current.kind !== 316 /* SyntaxKind.JSDoc */)
         current = current.parent;
     const host = current?.parent;
     return host !== undefined && isFunctionLike(host) ? host : undefined;
@@ -1704,13 +1806,13 @@ 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')
+    // `import.defer` and `import.source` are only valid as callees.
+    if (isImportPhaseMetaProperty(node))
         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 */);
+            c.error(node, 383 /* 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 */);
@@ -1718,13 +1820,13 @@ export function checkMetaProperty(c, node) {
 }
 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');
+    if (container.kind !== 178 /* SyntaxKind.Constructor */ &&
+        container.kind !== 264 /* SyntaxKind.FunctionDeclaration */ &&
+        container.kind !== 220 /* SyntaxKind.FunctionExpression */) {
+        c.error(node, 1836 /* 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);
+    const symbol = getSymbolOfDeclaration(c, container.kind === 178 /* SyntaxKind.Constructor */ ? container.parent : container);
     return symbol !== undefined ? getTypeOfSymbol(c, symbol) : c.errorType;
 }
 // ---- Import and export declarations
@@ -1737,14 +1839,14 @@ function isValidExternalImportOrExportDeclaration(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)
+    const inAmbientExternalModule = parent.kind === 270 /* SyntaxKind.ModuleBlock */ && isAmbientModule(parent.parent);
+    if (parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule)
         return false;
     if (inAmbientExternalModule &&
         isExternalModuleNameRelative(getText(moduleName)) &&
         !isModuleAugmentationExternal(parent.parent))
         return false;
-    if (node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+    if (node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */)
         return true;
     const attributes = getImportAttributes(node);
     if (attributes === undefined)
@@ -1754,14 +1856,33 @@ function isValidExternalImportOrExportDeclaration(node) {
             return false;
     return true;
 }
+/**
+ * Resolves the module an import or export in an illegal context names, when that context is still
+ * in a file's global scope (a block), to report a missing module. A side-effect import isn't resolved.
+ */
+function checkExternalModuleNameInGlobalScope(c, node) {
+    let container = node.parent;
+    while (container !== undefined && (getContainerFlags(container) & 1 /* ContainerFlags.IsContainer */) === 0)
+        container = container.parent;
+    if (container === undefined || container.kind !== 308 /* SyntaxKind.SourceFile */)
+        return;
+    if ((node.kind === 274 /* SyntaxKind.ImportDeclaration */ || node.kind === 347 /* SyntaxKind.JSImportDeclaration */) &&
+        node.importClause === undefined)
+        return;
+    const moduleName = getExternalModuleName(node);
+    if (moduleName !== undefined)
+        resolveExternalModuleName(c, node, moduleName, false, getTypeFromImportAttributes(c, getImportAttributes(node)));
+}
 function isInModuleElementContext(node) {
     const parent = node.parent.kind;
-    return (parent === 307 /* SyntaxKind.SourceFile */ || parent === 269 /* SyntaxKind.ModuleBlock */ || parent === 268 /* SyntaxKind.ModuleDeclaration */);
+    return (parent === 308 /* SyntaxKind.SourceFile */ || parent === 270 /* SyntaxKind.ModuleBlock */ || parent === 269 /* SyntaxKind.ModuleDeclaration */);
 }
 function getImportAttributes(node) {
-    if (node.kind === 273 /* SyntaxKind.ImportDeclaration */ || node.kind === 346 /* SyntaxKind.JSImportDeclaration */)
+    if (node.kind === 274 /* SyntaxKind.ImportDeclaration */ || node.kind === 347 /* SyntaxKind.JSImportDeclaration */)
+        return node.attributes;
+    if (node.kind === 280 /* SyntaxKind.ExportDeclaration */)
         return node.attributes;
-    if (node.kind === 279 /* SyntaxKind.ExportDeclaration */)
+    if (node.kind === 207 /* SyntaxKind.ImportType */)
         return node.attributes;
     return undefined;
 }
@@ -1771,7 +1892,7 @@ function hasImportClauseGrammarError(c, node) {
     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 */)
+        if (namedBindings !== undefined && namedBindings.kind === 277 /* SyntaxKind.NamedImports */)
             for (const specifier of namedBindings.elements.nodes)
                 if (getIsTypeOnly(specifier))
                     return !hasParseErrors(node);
@@ -1779,7 +1900,7 @@ function hasImportClauseGrammarError(c, node) {
     else if (node.phaseModifier === 166 /* SyntaxKind.DeferKeyword */) {
         if (node.name !== undefined)
             return !hasParseErrors(node);
-        if (namedBindings !== undefined && namedBindings.kind === 276 /* SyntaxKind.NamedImports */)
+        if (namedBindings !== undefined && namedBindings.kind === 277 /* SyntaxKind.NamedImports */)
             return !hasParseErrors(node);
         const moduleKind = getEmitModuleKind(c.compilerOptions);
         if (moduleKind !== ModuleKind.ESNext && moduleKind !== ModuleKind.Preserve)
@@ -1791,6 +1912,8 @@ function hasParseErrors(node) {
     return getSourceFileOfNode(node).diagnostics.length > 0;
 }
 export function checkImportDeclaration(c, node) {
+    if (!isInModuleElementContext(node))
+        checkExternalModuleNameInGlobalScope(c, node);
     if (!isInModuleElementContext(node) || !isValidExternalImportOrExportDeclaration(node)) {
         checkImportAttributes(c, node);
         return;
@@ -1805,7 +1928,7 @@ export function checkImportDeclaration(c, node) {
         const emittedAsCommonJS = c.host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === ModuleKind.CommonJS;
         let needsImportStar = false;
         if (namedBindings !== undefined) {
-            if (namedBindings.kind === 275 /* SyntaxKind.NamespaceImport */) {
+            if (namedBindings.kind === 276 /* SyntaxKind.NamespaceImport */) {
                 checkImportBinding(c, namedBindings);
                 if (emittedAsCommonJS) {
                     needsImportStar = true;
@@ -1813,7 +1936,7 @@ export function checkImportDeclaration(c, node) {
                 }
             }
             else {
-                resolvedModule = resolveExternalModuleName(c, node, declaration.moduleSpecifier, false);
+                resolvedModule = resolveExternalModuleName(c, node, declaration.moduleSpecifier, false, getTypeFromImportAttributes(c, declaration.attributes));
                 if (resolvedModule !== undefined)
                     for (const binding of namedBindings.elements.nodes)
                         checkImportBinding(c, binding);
@@ -1825,12 +1948,12 @@ export function checkImportDeclaration(c, node) {
         if (!isTypeOnly(clause) &&
             moduleKind >= ModuleKind.Node18 &&
             moduleKind <= ModuleKind.NodeNext &&
-            isOnlyImportableAsDefault(c, declaration.moduleSpecifier, resolvedModule) &&
+            isOnlyImportableAsDefault(c, declaration.moduleSpecifier, resolvedModule, getTypeFromImportAttributes(c, declaration.attributes)) &&
             !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));
+            c.error(declaration.moduleSpecifier, 456 /* 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);
+        resolveExternalModuleNameWorker(c, node, declaration.moduleSpecifier, 1009 /* Diagnostics.Cannot_find_module_or_type_declarations_for_side_effect_import_of_0 */, false, false, getTypeFromImportAttributes(c, declaration.attributes));
     checkImportAttributes(c, node);
 }
 function hasTypeJsonImportAttribute(node) {
@@ -1847,28 +1970,57 @@ function hasTypeJsonImportAttribute(node) {
 function checkImportBinding(c, node) {
     checkCollisionsForDeclarationName(c, node, getName(node));
     checkAliasSymbol(c, node);
-    if (node.kind === 277 /* SyntaxKind.ImportSpecifier */ &&
+    if (node.kind === 278 /* 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) {
+export 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);
+        checkTypeAssignableTo(c, checkImportAttributesExpression(c, node), getNullableType(c, importAttributesType, 4 /* TypeFlags.Undefined */), node, undefined);
 }
+/** The type of import attributes, which resolution matches against the attributes types of pattern ambient modules. */
 function getTypeFromImportAttributes(c, node) {
+    if (node === undefined)
+        return undefined;
+    if (node.kind === 302 /* SyntaxKind.ImportAttributes */)
+        return checkImportAttributesExpression(c, node);
+    return checkExpressionCached(c, node);
+}
+/** The import attributes type of the declaration `node` is the module specifier of. */
+export function getImportAttributesTypeForModuleSpecifier(c, moduleSpecifier) {
+    const parent = moduleSpecifier.parent;
+    switch (parent.kind) {
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+            return getTypeFromImportAttributes(c, getImportAttributes(parent));
+        case 203 /* SyntaxKind.LiteralType */:
+            if (parent.parent.kind === 207 /* SyntaxKind.ImportType */)
+                return getTypeFromImportAttributes(c, parent.parent.attributes);
+            return undefined;
+        case 215 /* SyntaxKind.CallExpression */: {
+            const args = parent.arguments.nodes;
+            if (isImportCall(parent) && args.length > 1)
+                return getTypeOfPropertyOfType(c, checkExpressionCached(c, args[1]), 'with');
+            return undefined;
+        }
+    }
+    return undefined;
+}
+export function checkImportAttributesExpression(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)));
+            c.symbolTypes.set(getSymbolId(member), getRegularTypeOfLiteralType(c, checkExpressionCached(c, attribute.value)));
             members.set(name, member);
         }
         const type = createAnonymousType(c, symbol, members, [], [], []);
@@ -1878,11 +2030,13 @@ function getTypeFromImportAttributes(c, node) {
     return c.resolvedTypes.get(node.id);
 }
 export function checkImportEqualsDeclaration(c, node) {
-    if (!isInModuleElementContext(node))
+    if (!isInModuleElementContext(node)) {
+        checkExternalModuleNameInGlobalScope(c, node);
         return;
+    }
     const declaration = node;
     const reference = declaration.moduleReference;
-    const isExternal = reference.kind === 284 /* SyntaxKind.ExternalModuleReference */;
+    const isExternal = reference.kind === 285 /* 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))
@@ -1901,14 +2055,14 @@ export function checkImportEqualsDeclaration(c, node) {
         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));
+            c.error(moduleName, 612 /* 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 */);
+        checkTypeNameIsReserved(c, declaration.name, 613 /* Diagnostics.Import_name_cannot_be_0 */);
 }
 function getFirstIdentifierOfEntityName(node) {
     let current = node;
-    while (current.kind === 167 /* SyntaxKind.QualifiedName */)
+    while (current.kind === 168 /* SyntaxKind.QualifiedName */)
         current = current.left;
     return current;
 }
@@ -1919,22 +2073,24 @@ function checkNamespaceExportName(c, name) {
     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 */);
+        grammarErrorOnNode(c, name, 1892 /* 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))
+    if (!isInModuleElementContext(node)) {
+        checkExternalModuleNameInGlobalScope(c, node);
         return;
+    }
     const declaration = node;
     if (declaration.moduleSpecifier === undefined || isValidExternalImportOrExportDeclaration(node)) {
         const clause = declaration.exportClause;
-        if (clause !== undefined && clause.kind === 280 /* SyntaxKind.NamedExports */) {
+        if (clause !== undefined && clause.kind === 281 /* SyntaxKind.NamedExports */) {
             for (const specifier of clause.elements.nodes)
                 checkExportSpecifier(c, specifier);
         }
         else {
-            const moduleSymbol = resolveExternalModuleName(c, node, declaration.moduleSpecifier, false);
+            const moduleSymbol = resolveExternalModuleName(c, node, declaration.moduleSpecifier, false, getTypeFromImportAttributes(c, declaration.attributes));
             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));
+                c.error(declaration.moduleSpecifier, 665 /* 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));
@@ -1963,7 +2119,7 @@ function checkExportSpecifier(c, node) {
         (symbol === c.undefinedSymbol ||
             symbol === c.globalThisSymbol ||
             (declarationCount(symbol) > 0 && isGlobalSourceFile(getDeclarationContainer(symbol.declaration)))))
-        c.error(exportedName, 795 /* Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module */, getText(exportedName));
+        c.error(exportedName, 802 /* Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module */, getText(exportedName));
     else
         markExportSpecifierAliasReferenced(c, node, symbol, exportedName);
 }
@@ -1974,12 +2130,12 @@ export function getDeclarationContainer(node) {
         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 */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 263 /* SyntaxKind.VariableDeclarationList */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 277 /* SyntaxKind.NamedImports */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 275 /* SyntaxKind.ImportClause */:
                 current = parent;
                 continue;
         }
@@ -1987,17 +2143,24 @@ export function getDeclarationContainer(node) {
     }
 }
 /** `export = e` and `export default e`; the grammar checker reports misplaced ones. */
+/** Whether an export assignment is in a namespace, rather than a file or an ambient module. */
+function isContainedByNamespace(node) {
+    const container = node.parent.kind === 308 /* SyntaxKind.SourceFile */ ? node.parent : node.parent.parent;
+    return container.kind === 269 /* SyntaxKind.ModuleDeclaration */ && !isAmbientModule(container);
+}
 export function checkExportAssignment(c, node) {
+    const declaration = node;
+    // The expression is checked also where an export assignment is a grammar error.
+    const exprType = checkExpressionCached(c, declaration.expression);
     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))
+    if (isContainedByNamespace(node))
         return;
+    const container = node.parent.kind === 308 /* SyntaxKind.SourceFile */ ? node.parent : node.parent.parent;
     const verbatimModuleSyntax = c.compilerOptions.verbatimModuleSyntax === true;
     const isIllegalExportDefaultInCJS = !isExportEquals &&
         !ambient &&
@@ -2015,7 +2178,6 @@ export function checkExportAssignment(c, node) {
             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 */
@@ -2028,11 +2190,7 @@ export function checkExportAssignment(c, node) {
             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);
@@ -2040,7 +2198,7 @@ export function checkExportAssignment(c, node) {
     const typeNode = getType(node);
     if (typeNode !== undefined) {
         const expr = getExpression(node);
-        checkTypeAssignableToAndOptionallyElaborate(c, checkExpressionCached(c, expr), getTypeFromTypeNode(c, typeNode), expr, expr);
+        checkTypeAssignableToAndOptionallyElaborate(c, exprType, getTypeFromTypeNode(c, typeNode), expr, expr);
     }
 }
 function checkIsolatedModulesExportAssignment(c, node, sym, typeOnlyDeclaration, isExportEquals) {
@@ -2080,36 +2238,36 @@ export function checkAliasSymbol(c, node) {
         ((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.error(node, node.kind === 283 /* SyntaxKind.ExportSpecifier */
+            ? 653 /* Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 */
+            : 615 /* Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0 */, symbolToString(c, symbol));
+    else if (node.kind !== 283 /* 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));
+        c.error(node, 992 /* 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 */)
+    if (node.kind === 278 /* 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 */);
+    if (node.kind === 283 /* SyntaxKind.ExportSpecifier */) {
+        c.error(errorNode, 1879 /* 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.kind !== 274 /* SyntaxKind.ImportDeclaration */ &&
+        declaration.kind !== 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        declaration.kind !== 262 /* SyntaxKind.VariableDeclaration */)
         declaration = declaration.parent;
     if (declaration !== undefined) {
-        const specifier = declaration.kind === 261 /* SyntaxKind.VariableDeclaration */
+        const specifier = declaration.kind === 262 /* SyntaxKind.VariableDeclaration */
             ? isVariableDeclarationInitializedToRequire(declaration)
                 ? getInitializer(declaration).arguments.nodes[0]
                 : undefined
@@ -2118,9 +2276,9 @@ function reportJSTypeAlias(c, node, symbol) {
             specifierText = getText(specifier);
     }
     let importText = 'import("' + specifierText + '")';
-    if (node.kind === 277 /* SyntaxKind.ImportSpecifier */)
+    if (node.kind === 278 /* 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);
+    c.error(errorNode, 1878 /* 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;
@@ -2128,26 +2286,26 @@ function checkIsolatedModulesAlias(c, node, symbol, target, targetFlags) {
     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 */: {
+            case 275 /* SyntaxKind.ImportClause */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */: {
                 if (verbatimModuleSyntax) {
-                    const message = node.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
-                        node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */
+                    const message = node.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+                        node.moduleReference.kind !== 285 /* 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 */;
+                            ? 397 /* Diagnostics.X_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled */
+                            : 398 /* 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 */ &&
+                    node.kind === 273 /* 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 */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 // `import type { A } from './a'; export { A }` is fine: one file shows the export is a type.
                 if (verbatimModuleSyntax ||
                     typeOnlyAlias === undefined ||
@@ -2162,13 +2320,14 @@ function checkIsolatedModulesAlias(c, node, symbol, target, targetFlags) {
         }
     }
     if (verbatimModuleSyntax &&
-        node.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.kind !== 273 /* 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 */ &&
+        node.kind !== 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+        node.kind !== 262 /* SyntaxKind.VariableDeclaration */ &&
+        node.kind !== 210 /* SyntaxKind.BindingElement */ &&
         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 */);
@@ -2176,7 +2335,7 @@ function checkIsolatedModulesAlias(c, node, symbol, target, targetFlags) {
         (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));
+        c.error(node, 887 /* 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) {
@@ -2196,7 +2355,7 @@ export function getIsolatedModulesLikeFlagName(c) {
 /** The file a module declaration or import names. */
 export function getExternalModuleFileFromDeclaration(c, declaration) {
     let specifier = undefined;
-    if (declaration.kind === 268 /* SyntaxKind.ModuleDeclaration */) {
+    if (declaration.kind === 269 /* SyntaxKind.ModuleDeclaration */) {
         const name = getName(declaration);
         if (name !== undefined && name.kind === 10 /* SyntaxKind.StringLiteral */)
             specifier = name;
@@ -2205,9 +2364,10 @@ export function getExternalModuleFileFromDeclaration(c, declaration) {
         specifier = getExternalModuleName(declaration);
     if (specifier === undefined)
         return undefined;
-    const moduleSymbol = resolveExternalModuleNameWorker(c, specifier, specifier, undefined, false, false);
+    // Used by emit and type printing after checking reported any resolution errors, so it adds none.
+    const moduleSymbol = resolveExternalModuleNameWorker(c, specifier, specifier, undefined, true, false, getTypeFromImportAttributes(c, getImportAttributes(declaration)));
     if (moduleSymbol === undefined)
         return undefined;
-    const file = getDeclarationOfKind(moduleSymbol, 307 /* SyntaxKind.SourceFile */);
+    const file = getDeclarationOfKind(moduleSymbol, 308 /* SyntaxKind.SourceFile */);
     return file === undefined ? undefined : file;
 }