tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/declarations.js

@@ -0,0 +1,2380 @@
+// The declaration transform: turns a source file into its declaration file. Keeps exported and
+// referenced declarations without their implementations, writes the types of declarations from
+// their annotations or the resolver, and elides imports the output doesn't use.
+import { getJSDoc } from '../parser.js';
+import { BindingElement, BindingPattern, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ComputedPropertyName, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExpressionWithTypeArguments, ExternalModuleReference, FileReference, ArrayTypeNode, ArrowFunction, BinaryExpression, TypeLiteralNode, UnionTypeNode, ElementAccessExpression, ExportSpecifier, FunctionDeclaration, FunctionExpression, FunctionTypeNode, ImportSpecifier, NodeVisitor, PropertyAccessExpression, QualifiedName, getArguments, GetAccessorDeclaration, HeritageClause, Identifier, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportTypeNode, IndexSignatureDeclaration, InterfaceDeclaration, KeywordTypeNode, LiteralTypeNode, MappedTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamespaceImport, NodeList, NumericLiteral, ParameterDeclaration, PrefixUnaryExpression, PrivateIdentifier, PropertyDeclaration, PropertySignatureDeclaration, JSDoc, JSDocText, SetAccessorDeclaration, SourceFile, StringLiteral, SyntaxList, TypeAliasDeclaration, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getExpression, getHeritageClauses, getMembers, getInitializer, getModifiers, getName, getParameters, getSymbol, getText, getType, getTypeParameters, isDeclarationNode, } from '../ast.js';
+import { isAmbientModule, isAnyImportOrReExport, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLiteralImportTypeNode, modifierToFlag, nodeIsMissing, nodeIsPresent, } from '../ast-utilities.js';
+import { getAssignmentDeclarationKind, getCombinedModifierFlags, getCombinedNodeFlags, getElementOrPropertyAccessName, getThisContainer, isVariableDeclarationInitializedToRequire, getSourceFileOfNode, getSourceTextOfNode, hasDynamicName, hasSyntacticModifier, isEntityNameExpression, isExternalOrCommonJSModule, isStatic, } from '../binder-utilities.js';
+import { getOutputPathsFor } from '../output-paths.js';
+import { getDirectoryPath, normalizeSlashes } from '../path.js';
+import { isModifier } from '../printer/utilities.js';
+import { getLeadingCommentRanges, getTrailingCommentRanges, identifierToKeywordKind, isIdentifierText, skipTrivia, stringToToken, } from '../scanner.js';
+import { getRelativePathToDirectoryOrUrl } from '../sourcemap.js';
+import { DiagnosticContext, canProduceDiagnostics, createDiagnosticForNode, declarationContext, declarationNameContext, noDiagnosticContext, } from './declarations-diagnostics.js';
+import { DeclarationTracker } from './declarations-tracker.js';
+import { Transformer } from './transformer.js';
+export class DeclarationTransformer extends Transformer {
+    host;
+    options;
+    resolver;
+    tracker;
+    declarationFilePath;
+    needsDeclare;
+    needsScopeFixMarker;
+    resultHasScopeMarker;
+    resultHasExternalModuleIndicator;
+    enclosingDeclaration;
+    /** Whether types are inside an object type, where new diagnostic contexts aren't entered. */
+    suppressNewDiagnosticContexts;
+    inClassExpressionDeclaration;
+    /** Transformed top-level declarations by original node; undefined for removed ones. */
+    lateStatementReplacements;
+    /** Functions with assigned properties (`f.x = 1`), transformed, by statement. */
+    expandoHosts;
+    /** The namespace members for the assigned properties of each function, by statement. */
+    expandoMembers;
+    /** The `export =` for a CommonJS `module.exports = …`. */
+    cjsExportAssignment;
+    /** The exports for CommonJS `exports.x = …` assignments. */
+    cjsExportMembers;
+    /** The name of the `module.exports` value, which `exports.x` members are nested in. */
+    cjsExportAssignmentName;
+    witnessedCjsExports;
+    /** `this.x` members found in a JavaScript class, and their keys. */
+    thisPropertyAssignments;
+    seenProperties;
+    constructor(context, host, options, resolver, declarationFilePath) {
+        super(context);
+        this.host = host;
+        this.options = options;
+        this.resolver = resolver;
+        this.tracker = new DeclarationTracker(resolver, options.isolatedDeclarations === true, options.stripInternal === true);
+        this.declarationFilePath = declarationFilePath;
+        this.needsDeclare = true;
+        this.needsScopeFixMarker = false;
+        this.resultHasScopeMarker = false;
+        this.resultHasExternalModuleIndicator = false;
+        this.enclosingDeclaration = context.factory.createToken(0 /* SyntaxKind.Unknown */);
+        this.suppressNewDiagnosticContexts = false;
+        this.inClassExpressionDeclaration = false;
+        this.lateStatementReplacements = new Map();
+        this.expandoHosts = new Map();
+        this.expandoMembers = new Map();
+        this.cjsExportAssignment = undefined;
+        this.cjsExportMembers = [];
+        this.cjsExportAssignmentName = undefined;
+        this.witnessedCjsExports = new Set();
+        this.thisPropertyAssignments = [];
+        this.seenProperties = new Set();
+    }
+    get diagnostics() {
+        return this.tracker.diagnostics;
+    }
+    visit(node) {
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile) {
+                    const narrowed = node;
+                    return this.visitSourceFile(narrowed);
+                }
+                break;
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 244 /* SyntaxKind.VariableStatement */:
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 278 /* SyntaxKind.ExportAssignment */:
+                return this.visitDeclarationStatement(node);
+            case 253 /* SyntaxKind.BreakStatement */:
+            case 252 /* SyntaxKind.ContinueStatement */:
+            case 260 /* SyntaxKind.DebuggerStatement */:
+            case 247 /* SyntaxKind.DoStatement */:
+            case 243 /* SyntaxKind.EmptyStatement */:
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+            case 249 /* SyntaxKind.ForStatement */:
+            case 246 /* SyntaxKind.IfStatement */:
+            case 257 /* SyntaxKind.LabeledStatement */:
+            case 254 /* SyntaxKind.ReturnStatement */:
+            case 256 /* SyntaxKind.SwitchStatement */:
+            case 258 /* SyntaxKind.ThrowStatement */:
+            case 259 /* SyntaxKind.TryStatement */:
+            case 248 /* SyntaxKind.WhileStatement */:
+            case 255 /* SyntaxKind.WithStatement */:
+            case 347 /* SyntaxKind.NotEmittedStatement */:
+            case 242 /* SyntaxKind.Block */:
+            case 283 /* SyntaxKind.MissingDeclaration */:
+            case 245 /* SyntaxKind.ExpressionStatement */:
+                return undefined;
+        }
+        return this.visitDeclarationSubtree(node);
+    }
+    // Source files
+    visitSourceFile(file) {
+        if (file.isDeclarationFile)
+            return file;
+        this.needsDeclare = true;
+        this.needsScopeFixMarker = false;
+        this.resultHasScopeMarker = false;
+        this.resultHasExternalModuleIndicator = false;
+        this.enclosingDeclaration = file;
+        this.suppressNewDiagnosticContexts = false;
+        this.lateStatementReplacements = new Map();
+        this.expandoHosts.clear();
+        this.expandoMembers.clear();
+        this.witnessedCjsExports.clear();
+        this.cjsExportAssignment = undefined;
+        this.cjsExportAssignmentName = undefined;
+        this.cjsExportMembers = [];
+        const tracker = this.tracker;
+        tracker.diagnosticContext = noDiagnosticContext;
+        tracker.lateMarkedStatements = [];
+        tracker.currentSourceFile = file;
+        this.resolver.precalculateDeclarationEmitVisibility(this.originalSourceFile(file));
+        // `module.exports =` first: `exports.x` members are nested under its name.
+        if (file.commonJSModuleIndicator !== undefined)
+            file.forEachChild(new ExpressionWalker(this, 0 /* ExpressionWalkerKind.ModuleExports */));
+        file.forEachChild(new ExpressionWalker(this, 1 /* ExpressionWalkerKind.Members */));
+        const statements = this.visitNodes(file.statements);
+        let combined = this.appendCjsExports(this.transformAndReplaceLatePaintedStatements(statements));
+        combined.pos = statements.pos;
+        combined.end = statements.end;
+        if (isExternalOrCommonJSModule(file) && file.isJS())
+            this.reportMultipleModuleExports(file);
+        if (isExternalOrCommonJSModule(file) &&
+            (!this.resultHasExternalModuleIndicator || (this.needsScopeFixMarker && !this.resultHasScopeMarker))) {
+            const nodes = combined.nodes.slice();
+            nodes.push(this.createEmptyExports());
+            const withMarker = new NodeList(combined.pos, combined.end, nodes);
+            combined = withMarker;
+        }
+        const result = this.factory.updateSourceFile(file, combined, file.endOfFileToken);
+        // Always a new node: references and the declaration flag differ from the input.
+        const updated = result === file
+            ? this.factory.updateSourceFile(file, new NodeList(combined.pos, combined.end, combined.nodes), file.endOfFileToken)
+            : result;
+        updated.isDeclarationFile = true;
+        updated.libReferenceDirectives = preservedReferences(file.libReferenceDirectives);
+        updated.typeReferenceDirectives = preservedReferences(file.typeReferenceDirectives);
+        updated.referencedFiles = this.getReferencedFiles(file, getDirectoryPath(normalizeSlashes(this.declarationFilePath)));
+        tracker.currentSourceFile = undefined;
+        this.cjsExportAssignment = undefined;
+        this.cjsExportAssignmentName = undefined;
+        this.cjsExportMembers = [];
+        return updated;
+    }
+    originalSourceFile(file) {
+        const original = this.context.mostOriginal(file);
+        if (original === undefined || original.kind !== 307 /* SyntaxKind.SourceFile */)
+            return file;
+        return original;
+    }
+    appendCjsExports(statements) {
+        if (this.cjsExportAssignment === undefined && this.cjsExportMembers.length === 0)
+            return statements;
+        const result = [];
+        if (this.cjsExportAssignment !== undefined)
+            appendFlattened(result, this.cjsExportAssignment);
+        for (const member of this.cjsExportMembers)
+            appendFlattened(result, member);
+        for (const statement of statements.nodes)
+            result.push(statement);
+        return this.factory.createNodeList(result);
+    }
+    reportMultipleModuleExports(file) {
+        const symbol = file.symbol;
+        const exportEquals = symbol === undefined || symbol.exports === undefined ? undefined : symbol.exports.get('export=');
+        if (exportEquals === undefined || exportEquals.declarations.length <= 1)
+            return false;
+        for (const declaration of exportEquals.declarations)
+            this.tracker.addDiagnostic(createDiagnosticForNode(declaration, 1513 /* Diagnostics.Multiple_module_exports_assignments_cannot_be_serialized_for_declaration_emit */, []));
+        return true;
+    }
+    createEmptyExports() {
+        return this.factory.created(new ExportDeclaration(undefined, false, this.factory.created(new NamedExports(this.factory.createNodeList([]))), undefined, undefined));
+    }
+    /** `/// <reference path>` directives with `preserve="true"`, relative to the output. */
+    getReferencedFiles(file, outputDirectory) {
+        const result = [];
+        for (const reference of file.referencedFiles) {
+            if (!reference.preserve)
+                continue;
+            const target = this.resolver.getSourceFileFromReference(file, reference);
+            if (target === undefined)
+                continue;
+            let fileName = target.fileName;
+            if (!target.isDeclarationFile) {
+                // The referenced file's declaration output, else its JavaScript output.
+                const paths = getOutputPathsFor(target.fileName, target.scriptKind === 6 /* ScriptKind.JSON */, this.options, this.host, true);
+                fileName = paths.declarationFilePath !== '' ? paths.declarationFilePath : paths.jsFilePath;
+                if (fileName === '')
+                    fileName = target.fileName;
+            }
+            if (fileName === '')
+                continue;
+            const relative = getRelativePathToDirectoryOrUrl(outputDirectory, fileName, this.host.useCaseSensitiveFileNames, this.host.currentDirectory);
+            result.push(new FileReference(-1, -1, relative, reference.resolutionMode, reference.preserve));
+        }
+        return result;
+    }
+    /**
+     * Replaces top-level declarations with their transformed forms. Transforming a declaration can
+     * mark more unexported declarations as referenced, so this runs until none are left.
+     */
+    transformAndReplaceLatePaintedStatements(statements) {
+        const tracker = this.tracker;
+        while (tracker.lateMarkedStatements.length > 0) {
+            const next = tracker.lateMarkedStatements.shift();
+            const saveNeedsDeclare = this.needsDeclare;
+            this.needsDeclare = next.parent !== undefined && next.parent.kind === 307 /* SyntaxKind.SourceFile */;
+            const result = this.transformTopLevelDeclaration(next);
+            this.needsDeclare = saveNeedsDeclare;
+            this.lateStatementReplacements.set(this.context.mostOriginal(next), result);
+        }
+        const results = [];
+        for (const statement of statements.nodes) {
+            if (!isLateVisibilityPaintedStatement(statement)) {
+                results.push(statement);
+                continue;
+            }
+            const original = this.context.mostOriginal(statement);
+            if (!this.lateStatementReplacements.has(original)) {
+                results.push(statement);
+                continue;
+            }
+            const replacement = this.lateStatementReplacements.get(original);
+            if (replacement === undefined)
+                continue;
+            const atTopLevel = statement.parent !== undefined && statement.parent.kind === 307 /* SyntaxKind.SourceFile */;
+            if (replacement instanceof SyntaxList) {
+                if (!this.needsScopeFixMarker || !this.resultHasExternalModuleIndicator)
+                    for (const child of replacement.children) {
+                        if (needsScopeMarker(child))
+                            this.needsScopeFixMarker = true;
+                        if (atTopLevel && isExternalModuleIndicator(child))
+                            this.resultHasExternalModuleIndicator = true;
+                    }
+                for (const child of replacement.children)
+                    results.push(child);
+            }
+            else {
+                if (needsScopeMarker(replacement))
+                    this.needsScopeFixMarker = true;
+                if (atTopLevel && isExternalModuleIndicator(replacement))
+                    this.resultHasExternalModuleIndicator = true;
+                results.push(replacement);
+            }
+        }
+        return this.factory.createNodeList(results);
+    }
+    // Diagnostic contexts
+    enterDiagnosticContext(input) {
+        const tracker = this.tracker;
+        const scope = new DiagnosticScope(tracker.diagnosticContext, tracker.errorNameNode, this.suppressNewDiagnosticContexts);
+        if (canProduceDiagnostics(input) && !this.suppressNewDiagnosticContexts)
+            tracker.diagnosticContext = declarationContext(input);
+        if ((input.kind === 188 /* SyntaxKind.TypeLiteral */ || input.kind === 201 /* SyntaxKind.MappedType */) &&
+            input.parent !== undefined &&
+            input.parent.kind !== 266 /* SyntaxKind.TypeAliasDeclaration */ &&
+            input.parent.kind !== 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+            this.suppressNewDiagnosticContexts = true;
+        return scope;
+    }
+    exitDiagnosticContext(scope) {
+        this.tracker.diagnosticContext = scope.context;
+        this.tracker.errorNameNode = scope.errorNameNode;
+        this.suppressNewDiagnosticContexts = scope.suppressNewDiagnosticContexts;
+        return true;
+    }
+    // Declarations below the top level
+    visitDeclarationSubtree(input) {
+        if (input === undefined)
+            return undefined;
+        if (this.shouldStripInternal(input))
+            return undefined;
+        if (isDeclaration(input)) {
+            if (this.isDeclarationAndNotVisible(input))
+                return undefined;
+            if (hasDynamicName(input)) {
+                const expression = getExpression(getName(input));
+                if (this.tracker.isolatedDeclarations) {
+                    // Computed names that aren't literal types can't be checked without types.
+                    if (!this.resolver.isDefinitelyReferenceToGlobalSymbolObject(expression)) {
+                        const parentKind = input.parent.kind;
+                        if (parentKind === 264 /* SyntaxKind.ClassDeclaration */ || parentKind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+                            this.tracker.addDiagnostic(createDiagnosticForNode(input, 1802 /* Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations */, []));
+                            return undefined;
+                        }
+                        if ((parentKind === 265 /* SyntaxKind.InterfaceDeclaration */ || parentKind === 188 /* SyntaxKind.TypeLiteral */) &&
+                            !isEntityNameExpression(expression, false)) {
+                            this.tracker.addDiagnostic(createDiagnosticForNode(input, 1779 /* Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations */, []));
+                            return undefined;
+                        }
+                    }
+                }
+                else if (!this.resolver.isLateBound(this.parseNode(input)) || !isEntityNameExpression(expression, false))
+                    return undefined;
+            }
+        }
+        // Implementations of overloads are elided.
+        if (isFunctionLike(input) && this.resolver.isImplementationOfOverload(input))
+            return undefined;
+        if (input.kind === 241 /* SyntaxKind.SemicolonClassElement */)
+            return undefined;
+        if (input instanceof HeritageClause) {
+            const types = input.types.nodes;
+            if (types.length === 0 || (types.length === 1 && nodeIsMissing(types[0])))
+                return undefined;
+        }
+        const previousEnclosingDeclaration = this.enclosingDeclaration;
+        if (isEnclosingDeclaration(input))
+            this.enclosingDeclaration = input;
+        const canProduceDiagnostic = canProduceDiagnostics(input);
+        const scope = this.enterDiagnosticContext(input);
+        const result = this.transformDeclarationSubtree(input);
+        if (result !== undefined && canProduceDiagnostic && hasDynamicName(input))
+            this.checkName(input);
+        this.exitDiagnosticContext(scope);
+        this.enclosingDeclaration = previousEnclosingDeclaration;
+        return result;
+    }
+    transformDeclarationSubtree(input) {
+        switch (input.kind) {
+            case 201 /* SyntaxKind.MappedType */:
+                if (input instanceof MappedTypeNode) {
+                    const narrowed = input;
+                    return this.transformMappedType(narrowed);
+                }
+                break;
+            case 299 /* SyntaxKind.HeritageClause */:
+                if (input instanceof HeritageClause) {
+                    const narrowed = input;
+                    return this.transformHeritageClause(narrowed);
+                }
+                break;
+            case 174 /* SyntaxKind.MethodSignature */:
+                if (input instanceof MethodSignatureDeclaration) {
+                    const narrowed = input;
+                    return this.transformMethodSignature(narrowed);
+                }
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                if (input instanceof MethodDeclaration) {
+                    const narrowed = input;
+                    return this.transformMethodDeclaration(narrowed);
+                }
+                break;
+            case 181 /* SyntaxKind.ConstructSignature */:
+                if (input instanceof ConstructSignatureDeclaration) {
+                    const narrowed = input;
+                    return this.transformConstructSignature(narrowed);
+                }
+                break;
+            case 177 /* SyntaxKind.Constructor */:
+                if (input instanceof ConstructorDeclaration) {
+                    const narrowed = input;
+                    return this.transformConstructor(narrowed);
+                }
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (input instanceof GetAccessorDeclaration) {
+                    const narrowed = input;
+                    return this.transformGetAccessor(narrowed);
+                }
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (input instanceof SetAccessorDeclaration) {
+                    const narrowed = input;
+                    return this.transformSetAccessor(narrowed);
+                }
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (input instanceof PropertyDeclaration) {
+                    const narrowed = input;
+                    return this.transformPropertyDeclaration(narrowed);
+                }
+                break;
+            case 172 /* SyntaxKind.PropertySignature */:
+                if (input instanceof PropertySignatureDeclaration) {
+                    const narrowed = input;
+                    return this.transformPropertySignature(narrowed);
+                }
+                break;
+            case 180 /* SyntaxKind.CallSignature */:
+                if (input instanceof CallSignatureDeclaration) {
+                    const narrowed = input;
+                    return this.transformCallSignature(narrowed);
+                }
+                break;
+            case 182 /* SyntaxKind.IndexSignature */:
+                if (input instanceof IndexSignatureDeclaration) {
+                    const narrowed = input;
+                    return this.transformIndexSignature(narrowed);
+                }
+                break;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                if (input instanceof VariableDeclaration) {
+                    const narrowed = input;
+                    return this.transformVariableDeclaration(narrowed);
+                }
+                break;
+            case 169 /* SyntaxKind.TypeParameter */:
+                if (input instanceof TypeParameterDeclaration) {
+                    const narrowed = input;
+                    return this.transformTypeParameter(narrowed);
+                }
+                break;
+            case 234 /* SyntaxKind.ExpressionWithTypeArguments */: {
+                const expression = input.expression;
+                if (isEntityName(expression) || isEntityNameExpression(expression, false))
+                    this.checkEntityNameVisibility(expression, this.enclosingDeclaration);
+                return this.visitEachChild(input);
+            }
+            case 184 /* SyntaxKind.TypeReference */:
+                this.checkEntityNameVisibility(input.typeName, this.enclosingDeclaration);
+                return this.visitEachChild(input);
+            case 195 /* SyntaxKind.ConditionalType */:
+                if (input instanceof ConditionalTypeNode) {
+                    const narrowed = input;
+                    return this.transformConditionalType(narrowed);
+                }
+                break;
+            case 185 /* SyntaxKind.FunctionType */:
+                if (input instanceof FunctionTypeNode) {
+                    const narrowed = input;
+                    return this.transformFunctionType(narrowed);
+                }
+                break;
+            case 186 /* SyntaxKind.ConstructorType */:
+                if (input instanceof ConstructorTypeNode) {
+                    const narrowed = input;
+                    return this.transformConstructorType(narrowed);
+                }
+                break;
+            case 206 /* SyntaxKind.ImportType */:
+                if (input instanceof ImportTypeNode) {
+                    const narrowed = input;
+                    return this.transformImportType(narrowed);
+                }
+                break;
+            case 187 /* SyntaxKind.TypeQuery */:
+                this.checkEntityNameVisibility(input.exprName, this.enclosingDeclaration);
+                return this.visitEachChild(input);
+            case 190 /* SyntaxKind.TupleType */: {
+                const result = this.visitEachChild(input);
+                if (isOriginalNodeSingleLine(this.context, input))
+                    this.context.addEmitFlags(result, 1 /* EmitFlags.SingleLine */);
+                return result;
+            }
+            case 308 /* SyntaxKind.JSDocTypeExpression */:
+                return this.visitNode(input.type);
+            case 310 /* SyntaxKind.JSDocAllType */:
+                return this.replaceWith(input, this.keyword(132 /* SyntaxKind.AnyKeyword */));
+            case 311 /* SyntaxKind.JSDocNullableType */:
+                // `?T` is `T | null`.
+                return this.replaceWith(input, this.createUnion(this.visitNode(input.type), this.factory.created(new LiteralTypeNode(this.factory.createKeywordExpression(105 /* SyntaxKind.NullKeyword */)))));
+            case 312 /* SyntaxKind.JSDocNonNullableType */:
+                return this.visitNode(input.type);
+            case 313 /* SyntaxKind.JSDocOptionalType */:
+                // `T=` is `T | undefined`.
+                return this.replaceWith(input, this.createUnion(this.visitNode(input.type), this.keyword(157 /* SyntaxKind.UndefinedKeyword */)));
+            case 314 /* SyntaxKind.JSDocVariadicType */:
+                // `...T` is `T[]`.
+                return this.replaceWith(input, this.factory.created(new ArrayTypeNode(this.visitNode(input.type))));
+            case 317 /* SyntaxKind.JSDocTypeLiteral */: {
+                const members = this.visitArray(input.jsdocPropertyTags ?? []);
+                return this.replaceWith(input, this.factory.created(new TypeLiteralNode(this.factory.createNodeList(members))));
+            }
+            case 340 /* SyntaxKind.JSDocPropertyTag */: {
+                const tag = input;
+                const type = tag.typeExpression === undefined ? undefined : this.visitNode(tag.typeExpression);
+                return this.replaceWith(input, this.factory.created(new PropertySignatureDeclaration(undefined, this.visitNode(tag.name), undefined, type, undefined)));
+            }
+        }
+        return this.visitEachChild(input);
+    }
+    createUnion(first, second) {
+        return this.factory.created(new UnionTypeNode(this.factory.createNodeList([first, second])));
+    }
+    replaceWith(original, replacement) {
+        this.context.setOriginal(replacement, original);
+        return replacement;
+    }
+    keyword(kind) {
+        return this.factory.created(new KeywordTypeNode(kind));
+    }
+    checkName(node) {
+        const tracker = this.tracker;
+        const oldContext = tracker.diagnosticContext;
+        if (!this.suppressNewDiagnosticContexts)
+            tracker.diagnosticContext = declarationNameContext(node);
+        const name = getName(node);
+        tracker.errorNameNode = name;
+        this.checkEntityNameVisibility(getExpression(name), this.enclosingDeclaration);
+        if (!this.suppressNewDiagnosticContexts)
+            tracker.diagnosticContext = oldContext;
+        tracker.errorNameNode = undefined;
+        return true;
+    }
+    checkEntityNameVisibility(entityName, enclosingDeclaration) {
+        return this.tracker.handleSymbolAccessibilityError(this.resolver.isEntityNameVisible(entityName, enclosingDeclaration));
+    }
+    transformMappedType(input) {
+        // The printer needs a template type.
+        const type = input.type === undefined ? this.keyword(132 /* SyntaxKind.AnyKeyword */) : this.visitNode(input.type);
+        return this.factory.updateMappedTypeNode(input, input.readonlyToken, this.visitNode(input.typeParameter), this.visitNode(input.nameType), input.questionToken, type, undefined);
+    }
+    transformHeritageClause(clause) {
+        const types = clause.types.nodes;
+        const retained = [];
+        for (const type of types) {
+            const expression = type.expression;
+            if (isEntityNameExpression(expression, false) ||
+                (clause.token === 95 /* SyntaxKind.ExtendsKeyword */ && expression.kind === 105 /* SyntaxKind.NullKeyword */))
+                retained.push(type);
+        }
+        if (retained.length === 0)
+            return undefined;
+        if (retained.length === types.length)
+            return this.visitEachChild(clause);
+        return this.factory.updateHeritageClause(clause, clause.token, this.visitNodes(this.factory.createNodeList(retained)));
+    }
+    transformImportType(input) {
+        if (!isLiteralImportTypeNode(input))
+            return input;
+        const argument = input.argument;
+        return this.factory.updateImportTypeNode(input, input.isTypeOf, this.factory.updateLiteralTypeNode(argument, this.rewriteModuleSpecifier(input, argument.literal)), input.attributes, input.qualifier, this.visitNodes(input.typeArguments));
+    }
+    transformConstructorType(input) {
+        return this.factory.updateConstructorTypeNode(input, this.ensureModifiers(input), this.visitNodes(input.typeParameters), this.updateParamList(input, input.parameters), this.visitNode(input.type));
+    }
+    transformFunctionType(input) {
+        return this.factory.updateFunctionTypeNode(input, this.visitNodes(input.typeParameters), this.updateParamList(input, input.parameters), this.visitNode(input.type));
+    }
+    transformConditionalType(input) {
+        const checkType = this.visitNode(input.checkType);
+        const extendsType = this.visitNode(input.extendsType);
+        const previousEnclosingDeclaration = this.enclosingDeclaration;
+        this.enclosingDeclaration = input.trueType;
+        const trueType = this.visitNode(input.trueType);
+        this.enclosingDeclaration = previousEnclosingDeclaration;
+        const falseType = this.visitNode(input.falseType);
+        return this.factory.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType);
+    }
+    transformTypeParameter(input) {
+        // Type parameters of private methods lose their constraints and defaults.
+        const parent = input.parent;
+        if (parent !== undefined &&
+            parent.kind === 175 /* SyntaxKind.MethodDeclaration */ &&
+            this.isPrivate(parent) &&
+            (input.defaultType !== undefined || input.constraint !== undefined))
+            return this.factory.updateTypeParameterDeclaration(input, input.modifiers, input.name, undefined, input.expression, undefined);
+        return this.visitEachChild(input);
+    }
+    transformVariableDeclaration(input) {
+        const file = this.tracker.currentSourceFile;
+        if (file !== undefined &&
+            file.commonJSModuleIndicator !== undefined &&
+            isVariableDeclarationInitializedToRequire(input))
+            return this.transformCjsRequireVariableDeclaration(input);
+        if (input.name instanceof BindingPattern)
+            return this.recreateBindingPattern(input.name);
+        // Variable types don't enter new diagnostic contexts.
+        this.suppressNewDiagnosticContexts = true;
+        return this.factory.updateVariableDeclaration(input, input.name, undefined, this.ensureType(input, false), this.ensureNoInitializer(input));
+    }
+    recreateBindingPattern(pattern) {
+        const results = [];
+        for (const element of pattern.elements.nodes) {
+            if (element === undefined || !(element instanceof BindingElement))
+                continue;
+            const result = this.recreateBindingElement(element);
+            if (result instanceof SyntaxList)
+                for (const child of result.children)
+                    results.push(child);
+            else if (result !== undefined)
+                results.push(result);
+        }
+        if (results.length === 0)
+            return undefined;
+        if (results.length === 1)
+            return results[0];
+        return this.factory.createSyntaxList(results);
+    }
+    recreateBindingElement(element) {
+        const name = element.name;
+        if (name === undefined || !this.getBindingNameVisible(element))
+            return undefined;
+        if (name instanceof BindingPattern) {
+            const narrowed = name;
+            return this.recreateBindingPattern(narrowed);
+        }
+        return this.factory.createVariableDeclaration(name, undefined, this.ensureType(element, false), undefined);
+    }
+    transformIndexSignature(input) {
+        const type = this.visitNode(input.type) ?? this.keyword(132 /* SyntaxKind.AnyKeyword */);
+        return this.factory.updateIndexSignatureDeclaration(input, this.ensureModifiers(input), this.updateParamList(input, input.parameters), type);
+    }
+    transformCallSignature(input) {
+        return this.factory.updateCallSignatureDeclaration(input, this.ensureTypeParams(input, input.typeParameters), this.updateParamList(input, input.parameters), this.ensureType(input, false));
+    }
+    transformPropertySignature(input) {
+        if (input.name instanceof PrivateIdentifier)
+            return undefined;
+        const result = this.factory.updatePropertySignatureDeclaration(input, this.ensureModifiers(input), input.name, input.postfixToken, this.ensureType(input, false), this.ensureNoInitializer(input));
+        this.preservePartialJsDoc(result, input);
+        return result;
+    }
+    /** Writes the description of a property from a JSDoc `@property` tag as its comment. */
+    preservePartialJsDoc(updated, original) {
+        if ((original.flags & 8 /* NodeFlags.Reparsed */) === 0)
+            return false;
+        const docs = getJSDoc(getSourceFileOfNode(original), original);
+        if (docs.length === 0 || !(docs[0] instanceof JSDoc))
+            return false;
+        const description = getTextOfJSDocComment(docs[0].comment);
+        if (description === '')
+            return false;
+        const comment = '*\n * ' + description.split('\n').join('\n * ') + '\n ';
+        this.context.addSyntheticLeadingComment(updated, 3 /* SyntaxKind.MultiLineCommentTrivia */, comment, true);
+        return true;
+    }
+    transformPropertyDeclaration(input) {
+        if (input.name instanceof PrivateIdentifier)
+            return undefined;
+        // Definite assignment assertions (`!`) are dropped.
+        const postfix = input.postfixToken;
+        return this.factory.updatePropertyDeclaration(input, this.ensureModifiers(input), input.name, postfix !== undefined && postfix.kind === 53 /* SyntaxKind.ExclamationToken */ ? undefined : postfix, this.ensureType(input, false), this.ensureNoInitializer(input));
+    }
+    transformSetAccessor(input) {
+        if (input.name instanceof PrivateIdentifier)
+            return undefined;
+        return this.factory.updateSetAccessorDeclaration(input, this.ensureModifiers(input), input.name, undefined, this.updateAccessorParamList(input, this.isPrivate(this.parseNode(input))), undefined, undefined, undefined);
+    }
+    transformGetAccessor(input) {
+        if (input.name instanceof PrivateIdentifier)
+            return undefined;
+        return this.factory.updateGetAccessorDeclaration(input, this.ensureModifiers(input), input.name, undefined, this.updateAccessorParamList(input, this.isPrivate(this.parseNode(input))), this.ensureType(input, false), undefined, undefined);
+    }
+    updateAccessorParamList(input, isPrivate) {
+        const params = [];
+        const parameters = getParameters(input).nodes;
+        if (!isPrivate) {
+            const thisParameter = parameters.length > 0 && isThisParameterNode(parameters[0]) ? parameters[0] : undefined;
+            if (thisParameter !== undefined)
+                params.push(this.ensureParameterNode(thisParameter));
+        }
+        if (input.kind === 179 /* SyntaxKind.SetAccessor */) {
+            let valueParameter = undefined;
+            if (!isPrivate) {
+                if (params.length === 1 && parameters.length >= 2)
+                    valueParameter = this.ensureParameterNode(parameters[1]);
+                else if (params.length === 0 && parameters.length >= 1)
+                    valueParameter = this.ensureParameterNode(parameters[0]);
+            }
+            // A missing value parameter is `value: any`, untyped when private.
+            valueParameter ??= this.factory.created(new ParameterDeclaration(undefined, undefined, this.factory.createIdentifier('value'), undefined, isPrivate ? undefined : this.keyword(132 /* SyntaxKind.AnyKeyword */), undefined));
+            params.push(valueParameter);
+        }
+        return this.factory.createNodeList(params);
+    }
+    transformConstructor(input) {
+        return this.factory.updateConstructorDeclaration(input, this.ensureModifiers(input), undefined, this.updateParamList(input, input.parameters), undefined, undefined, undefined);
+    }
+    transformConstructSignature(input) {
+        return this.factory.updateConstructSignatureDeclaration(input, this.ensureTypeParams(input, input.typeParameters), this.updateParamList(input, input.parameters), this.ensureType(input, false));
+    }
+    /** A private method is written as a property without a type. */
+    omitPrivateMethodType(input) {
+        const symbol = getSymbol(input);
+        if (symbol !== undefined && symbol.declarations.length > 0 && symbol.declarations[0] !== input)
+            return undefined;
+        const result = this.factory.created(new PropertyDeclaration(this.ensureModifiers(input), getName(input), undefined, undefined, undefined));
+        this.context.assignCommentRange(result, input);
+        return result;
+    }
+    transformMethodSignature(input) {
+        if (this.isPrivate(this.parseNode(input)))
+            return this.omitPrivateMethodType(input);
+        if (input.name instanceof PrivateIdentifier)
+            return undefined;
+        return this.factory.updateMethodSignatureDeclaration(input, this.ensureModifiers(input), input.name, input.postfixToken, this.ensureTypeParams(input, input.typeParameters), this.updateParamList(input, input.parameters), this.ensureType(input, false));
+    }
+    transformMethodDeclaration(input) {
+        if (this.isPrivate(this.parseNode(input)))
+            return this.omitPrivateMethodType(input);
+        if (input.name instanceof PrivateIdentifier)
+            return undefined;
+        return this.factory.updateMethodDeclaration(input, this.ensureModifiers(input), undefined, input.name, input.postfixToken, this.ensureTypeParams(input, input.typeParameters), this.updateParamList(input, input.parameters), this.ensureType(input, false), undefined, undefined);
+    }
+    // Top-level declarations
+    visitDeclarationStatement(input) {
+        if (input === undefined)
+            return undefined;
+        if (this.shouldStripInternal(input))
+            return undefined;
+        if (input instanceof ExportDeclaration) {
+            if (input.parent !== undefined && input.parent.kind === 307 /* SyntaxKind.SourceFile */)
+                this.resultHasExternalModuleIndicator = true;
+            this.resultHasScopeMarker = true;
+            return this.factory.updateExportDeclaration(input, input.modifiers, input.isTypeOnly, input.exportClause, this.rewriteModuleSpecifier(input, input.moduleSpecifier), this.tryGetResolutionModeOverride(input.attributes));
+        }
+        if (input instanceof ExportAssignment)
+            return this.transformExportAssignment(input, input, input.expression, input.isExportEquals);
+        // Transformed later, when it's known which unexported declarations are referenced.
+        const original = this.context.mostOriginal(input);
+        if (this.lateStatementReplacements.get(original) === undefined)
+            this.lateStatementReplacements.set(original, this.transformTopLevelDeclaration(input));
+        return input;
+    }
+    /** `export =`, `export default` or `module.exports =` of `expression`. */
+    transformExportAssignment(input, assignment, expression, isExportEquals) {
+        if (input.parent !== undefined && input.parent.kind === 307 /* SyntaxKind.SourceFile */)
+            this.resultHasExternalModuleIndicator = true;
+        this.resultHasScopeMarker = true;
+        if (expression instanceof Identifier &&
+            input.parent !== undefined &&
+            (input.parent.kind === 307 /* SyntaxKind.SourceFile */ || input.parent.kind === 269 /* SyntaxKind.ModuleBlock */)) {
+            const result = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, expression));
+            this.context.assignCommentRange(result, input);
+            return result;
+        }
+        const unwrapped = skipOuterExpressions(expression);
+        const name = this.getNameOfExportedExpression(unwrapped, isExportEquals);
+        // Class and function expressions become declarations.
+        if (unwrapped instanceof ClassExpression || isFunctionLike(unwrapped)) {
+            const declaration = unwrapped instanceof ClassExpression
+                ? this.transformClassExpressionToDeclaration(unwrapped, name, this.declareModifiers())
+                : this.transformFunctionLikeToDeclaration(unwrapped, name, this.declareModifiers());
+            this.context.assignCommentRange(declaration, input);
+            const exportAssignment = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, name));
+            this.context.addEmitFlags(exportAssignment, 384 /* EmitFlags.NoComments */);
+            return this.factory.createSyntaxList([exportAssignment, declaration]);
+        }
+        // Other expressions are written as a `_default` variable with the expression's type.
+        const tracker = this.tracker;
+        tracker.diagnosticContext = new DiagnosticContext(3 /* DiagnosticContextKind.DefaultExport */, input, undefined);
+        this.cjsExportAssignmentName = name;
+        tracker.pushErrorFallbackNode(assignment);
+        let initializer = undefined;
+        if (isPrimitiveLiteralValue(skipParenthesesOnly(expression), true))
+            initializer = this.resolver.createLiteralConstValue(this.context, this.parseNode(assignment), tracker);
+        const type = initializer === undefined ? this.ensureType(assignment, false) : undefined;
+        const declaration = this.factory.createVariableDeclaration(name, undefined, type, initializer);
+        tracker.popErrorFallbackNode();
+        const statement = this.createConstStatement(declaration);
+        const exportAssignment = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, name));
+        this.context.assignCommentRange(statement, input);
+        return this.factory.createSyntaxList([statement, exportAssignment]);
+    }
+    createConstStatement(declaration) {
+        return this.factory.createVariableStatement(this.declareModifiers(), this.factory.createVariableDeclarationList(this.factory.createNodeList([declaration]), 2 /* NodeFlags.Const */));
+    }
+    transformFunctionLikeToDeclaration(fn, name, modifiers) {
+        const fullSignature = getFullSignature(fn);
+        return this.factory.created(new FunctionDeclaration(modifiers, undefined, name, this.ensureTypeParams(fn, getTypeParameters(fn)), this.updateParamList(fn, getParameters(fn)), this.ensureType(fn, false), fullSignature === undefined ? undefined : this.visitNode(fullSignature), undefined));
+    }
+    /** A class expression as a declaration, for `export default (class {})` and CommonJS exports. */
+    transformClassExpressionToDeclaration(classExpression, name, modifiers) {
+        const previousEnclosingDeclaration = this.enclosingDeclaration;
+        this.enclosingDeclaration = classExpression;
+        const previousInClassExpression = this.inClassExpressionDeclaration;
+        this.inClassExpressionDeclaration = true;
+        const extraMembers = isInJSFile(classExpression) ? this.collectThisPropertyAssignments(classExpression) : [];
+        const members = this.buildClassMembers(classExpression, extraMembers);
+        const typeParameters = this.ensureTypeParams(classExpression, classExpression.typeParameters);
+        const heritageClauses = this.visitNodes(classExpression.heritageClauses);
+        this.enclosingDeclaration = previousEnclosingDeclaration;
+        this.inClassExpressionDeclaration = previousInClassExpression;
+        return this.factory.created(new ClassDeclaration(modifiers, name, typeParameters, heritageClauses, members));
+    }
+    declareModifiers() {
+        return this.factory.createModifierList(this.needsDeclare ? [this.factory.createToken(137 /* SyntaxKind.DeclareKeyword */)] : []);
+    }
+    /** The name of the variable for an exported expression: its own name if it has one, else `_default`. */
+    getNameOfExportedExpression(expression, isExportEquals) {
+        const name = this.tryGetNameOfAssignedExpression(expression);
+        if (name !== undefined) {
+            this.cjsExportAssignmentName = name;
+            return name;
+        }
+        const file = this.tracker.currentSourceFile;
+        // Only JavaScript names `export =` expressions `_exports`.
+        const base = isExportEquals && file !== undefined && file.isJS() ? '_exports' : '_default';
+        const result = this.factory.createUniqueName(base, 16 /* GeneratedIdentifierFlags.Optimistic */);
+        this.cjsExportAssignmentName = result;
+        return result;
+    }
+    /** The name of a named function or class expression, unique if it would shadow something. */
+    tryGetNameOfAssignedExpression(expression) {
+        let text = '';
+        if (expression.kind !== 212 /* SyntaxKind.PropertyAccessExpression */) {
+            const name = getName(expression);
+            if (name instanceof Identifier)
+                text = name.text;
+        }
+        if (expression instanceof Identifier)
+            text = expression.text;
+        if (text === '' || text === 'default')
+            return undefined;
+        if (this.resolver.isNameResolvable(this.enclosingDeclaration, text))
+            return this.factory.createUniqueName(text, 16 /* GeneratedIdentifierFlags.Optimistic */);
+        return this.factory.createIdentifier(text);
+    }
+    rewriteModuleSpecifier(parent, input) {
+        if (input === undefined)
+            return undefined;
+        if (parent.kind !== 268 /* SyntaxKind.ModuleDeclaration */ && parent.kind !== 206 /* SyntaxKind.ImportType */)
+            this.resultHasExternalModuleIndicator = true;
+        return input;
+    }
+    tryGetResolutionModeOverride(node) {
+        if (node === undefined)
+            return undefined;
+        return this.resolver.getResolutionModeOverride(node) !== undefined ? node : undefined;
+    }
+    /** The replacement statements for a direct child of a source file or module block. */
+    transformTopLevelDeclaration(input) {
+        if (input === undefined)
+            return undefined;
+        const tracker = this.tracker;
+        const marked = tracker.lateMarkedStatements;
+        if (marked.length > 0) {
+            const remaining = [];
+            for (const node of marked)
+                if (node !== input)
+                    remaining.push(node);
+            tracker.lateMarkedStatements = remaining;
+        }
+        if (this.shouldStripInternal(input))
+            return undefined;
+        if (input instanceof ImportEqualsDeclaration) {
+            const narrowed = input;
+            return this.transformImportEquals(narrowed);
+        }
+        if (input instanceof ImportDeclaration) {
+            const result = this.transformImportDeclaration(input);
+            // `import x = require()` in JavaScript is written as an import declaration.
+            if (result !== undefined && result.kind !== 273 /* SyntaxKind.ImportDeclaration */) {
+                // A copy of the declaration, as tsgo's clone: with its position and emit node.
+                const clone = this.factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, result.modifiers, result.importClause, result.moduleSpecifier, result.attributes));
+                clone.pos = result.pos;
+                clone.end = result.end;
+                this.context.setOriginal(clone, result);
+                return clone;
+            }
+            return result;
+        }
+        if (isDeclaration(input) && this.isDeclarationAndNotVisible(input))
+            return undefined;
+        if (isFunctionLike(input) && this.resolver.isImplementationOfOverload(input))
+            return undefined;
+        const original = this.context.mostOriginal(input);
+        if (this.expandoHosts.has(original))
+            return this.createFullExpandoBlock(original);
+        const previousEnclosingDeclaration = this.enclosingDeclaration;
+        if (isEnclosingDeclaration(input))
+            this.enclosingDeclaration = input;
+        const oldContext = tracker.diagnosticContext;
+        const oldName = tracker.errorNameNode;
+        if (canProduceDiagnostics(input))
+            tracker.diagnosticContext = declarationContext(input);
+        const saveNeedsDeclare = this.needsDeclare;
+        let result = undefined;
+        switch (input.kind) {
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                if (input instanceof TypeAliasDeclaration) {
+                    const narrowed = input;
+                    result = this.transformTypeAlias(narrowed);
+                }
+                break;
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+                if (input instanceof InterfaceDeclaration) {
+                    const narrowed = input;
+                    result = this.transformInterface(narrowed);
+                }
+                break;
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+                if (input instanceof FunctionDeclaration) {
+                    const narrowed = input;
+                    result = this.transformFunctionDeclaration(narrowed);
+                }
+                break;
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                if (input instanceof ModuleDeclaration) {
+                    const narrowed = input;
+                    result = this.transformModuleDeclaration(narrowed);
+                }
+                break;
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                if (input instanceof ClassDeclaration) {
+                    const narrowed = input;
+                    result = this.transformClassDeclaration(narrowed);
+                }
+                break;
+            case 244 /* SyntaxKind.VariableStatement */:
+                if (input instanceof VariableStatement) {
+                    const narrowed = input;
+                    result = this.transformVariableStatement(narrowed);
+                }
+                break;
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                if (input instanceof EnumDeclaration) {
+                    const narrowed = input;
+                    result = this.transformEnumDeclaration(narrowed);
+                }
+                break;
+            default:
+                throw new Error('Unhandled top-level node in declaration emit');
+        }
+        this.enclosingDeclaration = previousEnclosingDeclaration;
+        tracker.diagnosticContext = oldContext;
+        this.needsDeclare = saveNeedsDeclare;
+        tracker.errorNameNode = oldName;
+        return result;
+    }
+    transformTypeAlias(input) {
+        this.needsDeclare = false;
+        return this.factory.updateTypeAliasDeclaration(input, this.ensureModifiers(input), input.name, this.visitNodes(input.typeParameters), this.visitNode(input.type));
+    }
+    transformInterface(input) {
+        return this.factory.updateInterfaceDeclaration(input, this.ensureModifiers(input), input.name, this.visitNodes(input.typeParameters), this.visitNodes(input.heritageClauses), this.visitNodes(input.members));
+    }
+    transformFunctionDeclaration(input) {
+        if (this.resolver.isExpandoFunctionDeclaration(input))
+            this.tracker.reportExpandoFunctionErrors(input);
+        return this.factory.updateFunctionDeclaration(input, this.ensureModifiers(input), undefined, input.name, this.ensureTypeParams(input, input.typeParameters), this.updateParamList(input, input.parameters), this.ensureType(input, false), undefined, undefined);
+    }
+    transformModuleDeclaration(input) {
+        const modifiers = this.ensureModifiers(input);
+        const saveNeedsDeclare = this.needsDeclare;
+        this.needsDeclare = false;
+        const body = input.body;
+        let keyword = input.keyword;
+        if (keyword !== 162 /* SyntaxKind.GlobalKeyword */ && !(input.name instanceof StringLiteral))
+            keyword = 145 /* SyntaxKind.NamespaceKeyword */;
+        if (body !== undefined && body instanceof ModuleBlock) {
+            const oldNeedsScopeFix = this.needsScopeFixMarker;
+            const oldHasScopeFix = this.resultHasScopeMarker;
+            this.resultHasScopeMarker = false;
+            this.needsScopeFixMarker = false;
+            const statements = this.visitNodes(body.statements);
+            let lateStatements = this.transformAndReplaceLatePaintedStatements(statements);
+            // In a `declare`d namespace everything is exported already; unexported "privates" don't matter.
+            if ((input.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+                this.needsScopeFixMarker = false;
+            // With an `export {}` or `export =` there's nothing to do. Otherwise, if some statements
+            // are unexported, add `export {}`; if all are exported, drop the redundant `export`s.
+            if (!isGlobalScopeAugmentation(input) && !this.resultHasScopeMarker && !hasScopeMarker(lateStatements)) {
+                if (this.needsScopeFixMarker) {
+                    const nodes = lateStatements.nodes.slice();
+                    nodes.push(this.createEmptyExports());
+                    lateStatements = this.factory.createNodeList(nodes);
+                }
+                else
+                    lateStatements = this.stripExportModifiersOfList(lateStatements);
+            }
+            const updatedBody = this.factory.updateModuleBlock(body, lateStatements);
+            this.needsDeclare = saveNeedsDeclare;
+            this.needsScopeFixMarker = oldNeedsScopeFix;
+            this.resultHasScopeMarker = oldHasScopeFix;
+            return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, updatedBody);
+        }
+        if (body !== undefined) {
+            // A nested `namespace a.b` is transformed now: it needs no visibility painting.
+            this.visitNode(body);
+            const original = this.context.mostOriginal(body);
+            const inner = this.lateStatementReplacements.get(original);
+            this.lateStatementReplacements.delete(original);
+            this.needsDeclare = saveNeedsDeclare;
+            return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, inner);
+        }
+        this.needsDeclare = saveNeedsDeclare;
+        return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, undefined);
+    }
+    stripExportModifiersOfList(list) {
+        const nodes = [];
+        let changed = false;
+        for (const statement of list.nodes) {
+            const stripped = this.stripExportModifiers(statement);
+            if (stripped !== statement)
+                changed = true;
+            nodes.push(stripped);
+        }
+        return changed ? new NodeList(list.pos, list.end, nodes) : list;
+    }
+    stripExportModifiers(statement) {
+        const parseNode = this.context.parseNode(statement);
+        // `export import` stays: imports aren't implicitly exported. So does `export default`.
+        if (statement.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ ||
+            (parseNode !== undefined && this.resolver.getEffectiveDeclarationFlags(parseNode, 2048 /* ModifierFlags.Default */) !== 0) ||
+            !canHaveModifiers(statement))
+            return statement;
+        const flags = getCombinedModifierFlags(statement);
+        if ((flags & 32 /* ModifierFlags.Export */) === 0)
+            return statement;
+        return this.replaceModifiers(statement, this.createModifiers(flags & (131071 /* ModifierFlags.All */ ^ 32 /* ModifierFlags.Export */)));
+    }
+    /** `node` with other modifiers; for statements that can be exported. */
+    replaceModifiers(node, modifiers) {
+        if (node === undefined)
+            return node;
+        const factory = this.factory;
+        if (node instanceof VariableStatement)
+            return factory.updateVariableStatement(node, modifiers, node.declarationList);
+        if (node instanceof FunctionDeclaration)
+            return factory.updateFunctionDeclaration(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.fullSignature, node.body);
+        if (node instanceof ClassDeclaration)
+            return factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+        if (node instanceof InterfaceDeclaration)
+            return factory.updateInterfaceDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+        if (node instanceof TypeAliasDeclaration)
+            return factory.updateTypeAliasDeclaration(node, modifiers, node.name, node.typeParameters, node.type);
+        if (node instanceof EnumDeclaration)
+            return factory.updateEnumDeclaration(node, modifiers, node.name, node.members);
+        if (node instanceof ModuleDeclaration)
+            return factory.updateModuleDeclaration(node, modifiers, node.keyword, node.name, node.body);
+        if (node instanceof ImportDeclaration)
+            return factory.updateImportDeclaration(node, modifiers, node.importClause, node.moduleSpecifier, node.attributes);
+        if (node instanceof ExportDeclaration)
+            return factory.updateExportDeclaration(node, modifiers, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.attributes);
+        if (node instanceof ExportAssignment)
+            return factory.updateExportAssignment(node, modifiers, node.isExportEquals, node.type, node.expression);
+        return node;
+    }
+    /** Class members: parameter properties, a `#private` marker and the visited members. */
+    /** The members of a class declaration or expression. */
+    buildClassMembers(classNode, extraMembers) {
+        const classMembers = getMembers(classNode);
+        const tracker = this.tracker;
+        const parameterProperties = [];
+        const constructor = getFirstConstructorWithBody(classMembers);
+        if (constructor !== undefined) {
+            const oldContext = tracker.diagnosticContext;
+            for (const parameter of constructor.parameters.nodes) {
+                if (!(parameter instanceof ParameterDeclaration))
+                    continue;
+                if (!hasSyntacticModifier(parameter, 31 /* ModifierFlags.ParameterPropertyModifier */) ||
+                    this.shouldStripInternal(parameter))
+                    continue;
+                tracker.diagnosticContext = declarationContext(parameter);
+                if (parameter.name instanceof Identifier) {
+                    const property = this.factory.created(new PropertyDeclaration(this.ensureModifiers(parameter), parameter.name, parameter.questionToken, this.ensureType(parameter, false), this.ensureNoInitializer(parameter)));
+                    this.context.assignCommentRange(property, parameter);
+                    parameterProperties.push(property);
+                }
+                else if (parameter.name instanceof BindingPattern)
+                    // A binding pattern is an error, but written as properties anyway.
+                    this.walkBindingPattern(parameter.name, parameter, parameterProperties);
+            }
+            tracker.diagnosticContext = oldContext;
+        }
+        const members = [];
+        // A class with private names gets a `#private` member to keep it nominal.
+        for (const member of classMembers.nodes) {
+            const name = getName(member);
+            if (name instanceof PrivateIdentifier) {
+                members.push(this.factory.created(new PropertyDeclaration(undefined, this.factory.created(new PrivateIdentifier('#private')), undefined, undefined, undefined)));
+                break;
+            }
+        }
+        const lateIndexes = this.resolver.createLateBoundIndexSignatures(this.context, classNode, this.enclosingDeclaration, 531469 /* NodeBuilderFlags.DeclarationEmit */, tracker);
+        for (const index of lateIndexes)
+            members.push(index);
+        for (const property of parameterProperties)
+            members.push(property);
+        for (const member of extraMembers)
+            members.push(member);
+        const visited = this.visitNodes(classMembers);
+        if (visited !== undefined)
+            for (const member of visited.nodes)
+                members.push(member);
+        return this.factory.createNodeList(members);
+    }
+    walkBindingPattern(pattern, parameter, result) {
+        for (const element of pattern.elements.nodes) {
+            if (!(element instanceof BindingElement) || element.name === undefined)
+                continue;
+            if (element.name instanceof BindingPattern) {
+                this.walkBindingPattern(element.name, parameter, result);
+                continue;
+            }
+            result.push(this.factory.created(new PropertyDeclaration(this.ensureModifiers(parameter), element.name, undefined, this.ensureType(element, false), undefined)));
+        }
+        return true;
+    }
+    transformClassDeclaration(input) {
+        const previousEnclosingDeclaration = this.enclosingDeclaration;
+        this.enclosingDeclaration = defined(input);
+        const tracker = this.tracker;
+        tracker.errorNameNode = input.name;
+        tracker.pushErrorFallbackNode(input);
+        const modifiers = this.ensureModifiers(input);
+        const typeParameters = this.ensureTypeParams(input, input.typeParameters);
+        const extraMembers = isInJSFile(input) ? this.collectThisPropertyAssignments(input) : [];
+        const members = this.buildClassMembers(input, extraMembers);
+        const extendsClause = getClassExtendsHeritageElement(input);
+        let result;
+        if (extendsClause !== undefined &&
+            !isEntityNameExpression(extendsClause.expression, false) &&
+            extendsClause.expression.kind !== 105 /* SyntaxKind.NullKeyword */) {
+            // `class C extends f() {}` becomes `declare const C_base: T; class C extends C_base {}`.
+            tracker.reportInferenceFallback(extendsClause.expression);
+            const oldId = input.name !== undefined && nodeIsPresent(input.name) && input.name.text.length > 0
+                ? input.name.text
+                : 'default';
+            const newId = this.factory.createUniqueName(oldId + '_base', 16 /* GeneratedIdentifierFlags.Optimistic */);
+            tracker.diagnosticContext = new DiagnosticContext(4 /* DiagnosticContextKind.ExtendsExpression */, extendsClause, input.name);
+            const declaration = this.factory.createVariableDeclaration(newId, undefined, this.resolver.createTypeOfExpression(this.context, extendsClause.expression, input, 531469 /* NodeBuilderFlags.DeclarationEmit */, tracker) ?? this.keyword(132 /* SyntaxKind.AnyKeyword */), undefined);
+            const statement = this.factory.createVariableStatement(this.needsDeclare
+                ? this.factory.createModifierList([this.factory.createToken(137 /* SyntaxKind.DeclareKeyword */)])
+                : undefined, this.factory.createVariableDeclarationList(this.factory.createNodeList([declaration]), 2 /* NodeFlags.Const */));
+            const clause = extendsClause.parent;
+            const heritageClause = this.factory.updateHeritageClause(clause, clause.token, this.factory.createNodeList([
+                defined(this.factory.updateExpressionWithTypeArguments(extendsClause, newId, this.visitNodes(extendsClause.typeArguments))),
+            ]));
+            const heritageClauses = [defined(heritageClause)];
+            // The rest are `implements` clauses.
+            const retained = this.visitNodes(input.heritageClauses);
+            if (retained !== undefined)
+                for (const other of retained.nodes)
+                    heritageClauses.push(other);
+            result = this.factory.createSyntaxList([
+                statement,
+                defined(this.factory.updateClassDeclaration(input, modifiers, input.name, typeParameters, this.factory.createNodeList(heritageClauses), members)),
+            ]);
+        }
+        else
+            result = defined(this.factory.updateClassDeclaration(input, modifiers, input.name, typeParameters, this.visitNodes(input.heritageClauses), members));
+        tracker.popErrorFallbackNode();
+        this.enclosingDeclaration = previousEnclosingDeclaration;
+        return result;
+    }
+    transformVariableStatement(input) {
+        const declarations = input.declarationList.declarations.nodes;
+        let visible = false;
+        for (const declaration of declarations)
+            if (this.getBindingNameVisible(declaration)) {
+                visible = true;
+                break;
+            }
+        if (!visible)
+            return undefined;
+        let normal = declarations;
+        const imports = [];
+        const file = this.tracker.currentSourceFile;
+        if (file !== undefined && file.commonJSModuleIndicator !== undefined) {
+            // `const x = require("m")` declarations become imports.
+            normal = [];
+            for (const declaration of declarations) {
+                if (isVariableDeclarationInitializedToRequire(declaration)) {
+                    const visited = this.visit(declaration);
+                    if (visited !== undefined)
+                        imports.push(visited);
+                }
+                else
+                    normal.push(declaration);
+            }
+        }
+        const nodes = this.visitArray(normal);
+        if (nodes.length === 0)
+            return imports.length > 0 ? this.factory.createSyntaxList(imports) : undefined;
+        const list = this.factory.createNodeList(nodes);
+        const modifiers = this.ensureModifiers(input);
+        const declarationList = input.declarationList;
+        let updatedList;
+        const blockScope = getCombinedNodeFlags(declarationList) & 7 /* NodeFlags.BlockScoped */;
+        if (blockScope === 4 /* NodeFlags.Using */ || blockScope === 6 /* NodeFlags.AwaitUsing */) {
+            // `using` declarations are written as `const`.
+            updatedList = this.factory.createVariableDeclarationList(list, 2 /* NodeFlags.Const */);
+            this.context.setOriginal(updatedList, declarationList);
+            this.context.setCommentRange(updatedList, declarationList.pos, declarationList.end);
+            updatedList.pos = declarationList.pos;
+            updatedList.end = declarationList.end;
+        }
+        else
+            updatedList = this.factory.updateVariableDeclarationList(declarationList, list, declarationList.flags);
+        const result = this.factory.updateVariableStatement(input, modifiers, updatedList);
+        if (imports.length === 0)
+            return result;
+        imports.push(defined(result));
+        return this.factory.createSyntaxList(imports);
+    }
+    transformEnumDeclaration(input) {
+        const members = [];
+        for (const member of input.members.nodes) {
+            if (member === undefined || !(member instanceof EnumMember) || this.shouldStripInternal(member))
+                continue;
+            // Initializers are rewritten to their constant values.
+            const value = this.resolver.getEnumMemberValue(member);
+            if (this.tracker.isolatedDeclarations &&
+                member.initializer !== undefined &&
+                value.hasExternalReferences &&
+                member.name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+                this.tracker.addDiagnostic(createDiagnosticForNode(member, 1785 /* Diagnostics.Enum_member_initializers_must_be_computable_without_references_to_external_symbols_with_isolatedDeclarations */, []));
+            let initializer = undefined;
+            if (value.kind === 1 /* ConstantKind.Number */)
+                initializer = this.createNumber(value.number);
+            else if (value.kind === 2 /* ConstantKind.String */)
+                initializer = this.factory.createStringLiteral(value.string, 0 /* TokenFlags.None */);
+            const result = defined(this.factory.updateEnumMember(member, member.name, initializer));
+            this.context.assignCommentRange(result, member);
+            members.push(result);
+        }
+        return this.factory.updateEnumDeclaration(input, this.ensureModifiers(input), input.name, this.factory.createNodeList(members));
+    }
+    /** A number as an expression: a literal, `-literal`, `Infinity`, `-Infinity` or `NaN`. */
+    createNumber(value) {
+        const factory = this.factory;
+        if (value !== value)
+            return factory.createIdentifier('NaN');
+        if (value === Infinity)
+            return factory.createIdentifier('Infinity');
+        if (value === -Infinity)
+            return factory.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, factory.createIdentifier('Infinity')));
+        if (value < 0 || (value === 0 && 1 / value < 0))
+            return factory.created(new PrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, factory.createNumericLiteral(String(-value))));
+        return factory.createNumericLiteral(String(value));
+    }
+    // JavaScript and assigned properties
+    /** `const x = require("m")` as `import x = require("m")`, `const { a } = require("m")` as `import { a } from "m"`. */
+    transformCjsRequireVariableDeclaration(input) {
+        const call = skipParenthesesOnly(input.initializer);
+        const specifier = this.rewriteModuleSpecifier(input, getArguments(call).nodes[0]);
+        const name = input.name;
+        if (name instanceof Identifier)
+            return this.factory.created(new ImportEqualsDeclaration(undefined, false, name, this.factory.created(new ExternalModuleReference(specifier))));
+        if (!(name instanceof BindingPattern) || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+            return undefined;
+        const specifiers = [];
+        for (const element of name.elements.nodes) {
+            // Nested destructuring is skipped.
+            if (!(element instanceof BindingElement) || !(element.name instanceof Identifier))
+                continue;
+            specifiers.push(this.factory.created(new ImportSpecifier(false, element.propertyName, element.name)));
+        }
+        const clause = this.factory.created(new ImportClause(undefined, undefined, this.factory.created(new NamedImports(this.factory.createNodeList(specifiers)))));
+        return this.factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, clause, specifier, undefined));
+    }
+    /** Finds `module.exports =` assignments anywhere in the file. */
+    visitModuleExportsAssignment(node) {
+        const file = this.tracker.currentSourceFile;
+        if (file.commonJSModuleIndicator === undefined ||
+            getAssignmentDeclarationKind(node) !== 1 /* JSDeclarationKind.ModuleExports */)
+            return false;
+        const scope = this.enterDiagnosticContext(node);
+        const result = this.transformExportAssignment(node.parent, node, node.right, true);
+        this.exitDiagnosticContext(scope);
+        if (result === undefined)
+            return false;
+        this.cjsExportAssignment = result;
+        this.resultHasScopeMarker = true;
+        this.resultHasExternalModuleIndicator = true;
+        return true;
+    }
+    /** Finds assigned properties (`f.x = 1`) and CommonJS exports (`exports.x = 1`) anywhere in the file. */
+    visitNestedExpression(node) {
+        if (node === undefined)
+            return false;
+        const kind = getAssignmentDeclarationKind(node);
+        if (kind === 0 /* JSDeclarationKind.None */)
+            return false;
+        const scope = this.enterDiagnosticContext(node);
+        const file = this.tracker.currentSourceFile;
+        switch (kind) {
+            case 4 /* JSDeclarationKind.Property */:
+                if (node instanceof BinaryExpression)
+                    this.transformExpandoAssignment(node);
+                break;
+            case 2 /* JSDeclarationKind.ExportsProperty */:
+                if (file.commonJSModuleIndicator !== undefined) {
+                    const name = getElementOrPropertyAccessName(node.left);
+                    if (name !== undefined) {
+                        const result = this.transformCommonJSExport(node, this.getNameExpressionPreferringIdentifier(name));
+                        if (result !== undefined)
+                            this.cjsExportMembers.push(result);
+                    }
+                }
+                break;
+            case 6 /* JSDeclarationKind.ObjectDefinePropertyExports */:
+                if (file.commonJSModuleIndicator !== undefined) {
+                    const result = this.transformCommonJSExport(node, this.getNameExpressionPreferringIdentifier(getArguments(node).nodes[1]));
+                    if (result !== undefined)
+                        this.cjsExportMembers.push(result);
+                }
+                break;
+        }
+        this.exitDiagnosticContext(scope);
+        return true;
+    }
+    /** A property name as an identifier when it can be one; keywords other than `default` stay strings. */
+    getNameExpressionPreferringIdentifier(name) {
+        let result = name;
+        if (name instanceof NumericLiteral)
+            result = this.factory.createStringLiteral(name.text, 0 /* TokenFlags.None */);
+        if ((result.kind === 10 /* SyntaxKind.StringLiteral */ || result.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */) &&
+            isIdentifierText(getText(result))) {
+            const text = getText(result);
+            const keyword = identifierToKeywordKind(text);
+            if (keyword === 0 /* SyntaxKind.Unknown */ ||
+                keyword === 79 /* SyntaxKind.Identifier */ ||
+                keyword === 89 /* SyntaxKind.DefaultKeyword */) {
+                // A parse tree node, so names it uses are resolved where it's written.
+                const identifier = new Identifier(text);
+                identifier.parent = name.parent;
+                return identifier;
+            }
+        }
+        return result;
+    }
+    transformCommonJSExport(input, name) {
+        const result = this.transformCommonJSExportWorker(input, name);
+        return result === undefined ? undefined : this.wrapInCJSExportNamespace(result);
+    }
+    transformCommonJSExportWorker(input, name) {
+        if (input === undefined)
+            return undefined;
+        const nameText = name.kind === 79 /* SyntaxKind.Identifier */ || name.kind === 10 /* SyntaxKind.StringLiteral */ ? getText(name) : '';
+        if (nameText !== '' && this.witnessedCjsExports.has(nameText))
+            return undefined;
+        this.witnessedCjsExports.add(nameText);
+        this.resultHasExternalModuleIndicator = true;
+        this.resultHasScopeMarker = true;
+        const tracker = this.tracker;
+        // At the top level, `exports.x = y` is written as `export { y as x }`.
+        const statement = input.parent;
+        if (isCommonJSAliasExport(input) &&
+            statement !== undefined &&
+            statement.kind === 245 /* SyntaxKind.ExpressionStatement */ &&
+            statement.parent !== undefined &&
+            statement.parent.kind === 307 /* SyntaxKind.SourceFile */)
+            return this.transformBinaryExpressionToExportDeclaration(input, name);
+        if (input instanceof BinaryExpression) {
+            const right = skipParenthesesOnly(input.right);
+            if (right instanceof ClassExpression)
+                return this.transformCommonJSClassExport(input, right, name);
+        }
+        if (name instanceof Identifier) {
+            if (name.text === 'default') {
+                // `declare const _default: T; export default _default;`
+                const newId = this.factory.createUniqueName('_default', 16 /* GeneratedIdentifierFlags.Optimistic */);
+                tracker.diagnosticContext = new DiagnosticContext(3 /* DiagnosticContextKind.DefaultExport */, input, undefined);
+                tracker.pushErrorFallbackNode(input);
+                const declaration = this.factory.createVariableDeclaration(newId, undefined, this.ensureType(input, false), undefined);
+                tracker.popErrorFallbackNode();
+                const variable = this.createConstStatement(declaration);
+                const assignment = this.factory.created(new ExportAssignment(getModifiers(input), false, undefined, newId));
+                this.context.assignCommentRange(variable, input);
+                this.context.addEmitFlags(assignment, 384 /* EmitFlags.NoComments */);
+                return this.factory.createSyntaxList([variable, assignment]);
+            }
+            const referenced = this.resolver.getReferencedValueDeclaration(name);
+            // Inlined as `export var x: T` unless the name refers to something else.
+            if (referenced === input || referenced === undefined) {
+                tracker.pushErrorFallbackNode(input);
+                const declaration = this.factory.createVariableDeclaration(name, undefined, this.ensureType(input, false), undefined);
+                tracker.popErrorFallbackNode();
+                const modifiers = [this.factory.createToken(94 /* SyntaxKind.ExportKeyword */)];
+                if (this.needsDeclare)
+                    modifiers.push(this.factory.createToken(137 /* SyntaxKind.DeclareKeyword */));
+                return this.factory.createVariableStatement(this.factory.createModifierList(modifiers), this.factory.createVariableDeclarationList(this.factory.createNodeList([declaration]), 0 /* NodeFlags.None */));
+            }
+        }
+        // `declare const _exported: T; export { _exported as "name" };`
+        const newId = this.factory.createUniqueName('_exported', 16 /* GeneratedIdentifierFlags.Optimistic */);
+        tracker.diagnosticContext = new DiagnosticContext(3 /* DiagnosticContextKind.DefaultExport */, input, undefined);
+        tracker.pushErrorFallbackNode(input);
+        const declaration = this.factory.createVariableDeclaration(newId, undefined, this.ensureType(input, false), undefined);
+        tracker.popErrorFallbackNode();
+        const variable = this.createConstStatement(declaration);
+        const exportDeclaration = this.createExportDeclaration(newId, name);
+        this.context.assignCommentRange(variable, input);
+        this.context.addEmitFlags(exportDeclaration, 384 /* EmitFlags.NoComments */);
+        return this.factory.createSyntaxList([variable, exportDeclaration]);
+    }
+    /** `exports.K = class K {}` as a class declaration, in a namespace if its name differs or is used inside. */
+    transformCommonJSClassExport(input, right, name) {
+        const factory = this.factory;
+        const tracker = this.tracker;
+        const classExpressionName = right.name;
+        if (classExpressionName !== undefined && classExpressionName.text.length > 0) {
+            // Watch for the class naming itself in its members' types.
+            tracker.watchedClassSymbol = right.symbol;
+            tracker.classSymbolTracked = false;
+            const className = factory.createIdentifier(classExpressionName.text);
+            const classDeclaration = this.transformClassExpressionToDeclaration(right, className, factory.createModifierList([factory.createToken(94 /* SyntaxKind.ExportKeyword */)]));
+            this.context.assignCommentRange(classDeclaration, input);
+            const namesDiffer = !(name instanceof Identifier) || classExpressionName.text !== name.text;
+            const needsIsolation = namesDiffer || tracker.classSymbolTracked;
+            tracker.watchedClassSymbol = undefined;
+            tracker.classSymbolTracked = false;
+            if (needsIsolation) {
+                const namespaceName = factory.createUniqueName('_ns', 16 /* GeneratedIdentifierFlags.Optimistic */);
+                const namespace = factory.created(new ModuleDeclaration(this.declareModifiers(), 145 /* SyntaxKind.NamespaceKeyword */, namespaceName, factory.created(new ModuleBlock(factory.createNodeList([classDeclaration])))));
+                const aliasBase = name instanceof Identifier && isIdentifierText('_' + name.text) ? '_' + name.text : '_exported';
+                const alias = factory.createUniqueName(aliasBase, 16 /* GeneratedIdentifierFlags.Optimistic */);
+                const importEquals = factory.created(new ImportEqualsDeclaration(undefined, false, alias, factory.created(new QualifiedName(namespaceName, className))));
+                const exportDeclaration = this.createExportDeclaration(alias, name);
+                this.context.addEmitFlags(exportDeclaration, 384 /* EmitFlags.NoComments */);
+                return factory.createSyntaxList([namespace, importEquals, exportDeclaration]);
+            }
+            const modifiers = [factory.createToken(94 /* SyntaxKind.ExportKeyword */)];
+            if (this.needsDeclare)
+                modifiers.push(factory.createToken(137 /* SyntaxKind.DeclareKeyword */));
+            return this.replaceModifiers(classDeclaration, factory.createModifierList(modifiers));
+        }
+        const modifiers = [factory.createToken(94 /* SyntaxKind.ExportKeyword */)];
+        if (this.needsDeclare)
+            modifiers.push(factory.createToken(137 /* SyntaxKind.DeclareKeyword */));
+        const className = name !== undefined && name instanceof Identifier
+            ? name
+            : factory.createUniqueName('_class', 16 /* GeneratedIdentifierFlags.Optimistic */);
+        const classDeclaration = this.transformClassExpressionToDeclaration(right, className, factory.createModifierList(modifiers));
+        this.context.assignCommentRange(classDeclaration, input);
+        if (name instanceof Identifier)
+            return classDeclaration;
+        // A name that isn't an identifier is exported by a specifier.
+        const exportDeclaration = this.createExportDeclaration(className, name);
+        this.context.addEmitFlags(exportDeclaration, 384 /* EmitFlags.NoComments */);
+        return factory.createSyntaxList([classDeclaration, exportDeclaration]);
+    }
+    createExportDeclaration(local, name) {
+        const factory = this.factory;
+        return factory.created(new ExportDeclaration(undefined, false, factory.created(new NamedExports(factory.createNodeList([factory.created(new ExportSpecifier(false, local, name))]))), undefined, undefined));
+    }
+    /** `exports.x = y` and `f.x = y` as `export { y as x }`. */
+    transformBinaryExpressionToExportDeclaration(input, name) {
+        let propertyName = input.right;
+        // Keeps the declaration the name refers to.
+        this.tracker.handleSymbolAccessibilityError(this.resolver.isEntityNameVisible(propertyName, this.enclosingDeclaration));
+        if (name instanceof Identifier && propertyName instanceof Identifier && propertyName.text === name.text)
+            propertyName = undefined;
+        return this.createExportDeclaration(propertyName, name);
+    }
+    /** CommonJS exports of a file with `module.exports =` are members of a namespace of its name. */
+    wrapInCJSExportNamespace(content) {
+        const name = this.cjsExportAssignmentName;
+        if (name === undefined)
+            return content;
+        const members = content instanceof SyntaxList ? content.children : [content];
+        const stripped = [];
+        for (const member of members)
+            stripped.push(this.stripDeclareModifier(member));
+        return this.factory.created(new ModuleDeclaration(this.declareModifiers(), 145 /* SyntaxKind.NamespaceKeyword */, name, this.factory.created(new ModuleBlock(this.factory.createNodeList(stripped)))));
+    }
+    stripDeclareModifier(node) {
+        const modifiers = getModifiers(node);
+        if (modifiers === undefined || (modifiers.modifierFlags & 128 /* ModifierFlags.Ambient */) === 0)
+            return node;
+        const kept = [];
+        for (const modifier of modifiers.nodes)
+            if (modifier.kind !== 137 /* SyntaxKind.DeclareKeyword */)
+                kept.push(modifier);
+        return this.replaceModifiers(node, this.factory.createModifierList(kept));
+    }
+    /** Writes `f.x = 1` as a namespace member of `f`, kept with `f` if it's emitted. */
+    transformExpandoAssignment(node) {
+        const symbol = node.symbol;
+        if (symbol === undefined || (symbol.flags & 67108864 /* SymbolFlags.Assignment */) === 0)
+            return false;
+        const left = node.left;
+        const namespace = getLeftmostAccessExpression(left);
+        if (!(namespace instanceof Identifier))
+            return false;
+        const declaration = this.resolver.getReferencedValueDeclaration(namespace);
+        if (declaration === undefined || this.shouldStripInternal(declaration))
+            return false;
+        if (declaration instanceof VariableDeclaration && declaration.type !== undefined)
+            return false;
+        if (declaration instanceof FunctionDeclaration && declaration.fullSignature !== undefined)
+            return false;
+        // A variable gets a type instead, unless it's a function.
+        if (declaration instanceof VariableDeclaration &&
+            (declaration.initializer === undefined || !isFunctionLike(declaration.initializer)))
+            return false;
+        const host = getSymbol(declaration);
+        if (host === undefined)
+            return false;
+        const name = this.factory.createIdentifier(namespace.text);
+        const property = this.tryGetPropertyName(left);
+        if (property === '' || !isIdentifierText(property))
+            return false;
+        if (isDeclaration(declaration) && this.isDeclarationAndNotVisible(declaration))
+            return false;
+        if (declaration instanceof FunctionDeclaration && !shouldEmitFunctionProperties(declaration))
+            return false;
+        this.transformExpandoHost(name, declaration);
+        const exportName = this.factory.createIdentifier(property);
+        let localName = this.tryGetNameOfAssignedExpression(node);
+        // The property's name works as the local name if it neither conflicts nor is a keyword.
+        if (localName === undefined &&
+            !this.resolver.isNameResolvable(this.enclosingDeclaration, property) &&
+            !isNonContextualKeyword(stringToToken(property)))
+            localName = exportName;
+        if (localName === undefined || isNonContextualKeyword(stringToToken(localName.text)))
+            localName = this.factory.createGeneratedNameForNode(node, 0 /* GeneratedIdentifierFlags.None */, '', '');
+        const hostId = this.getExpandoHostId(declaration);
+        const scope = this.enterDiagnosticContext(node);
+        let members = this.expandoMembers.get(hostId);
+        if (members === undefined) {
+            members = [];
+            this.expandoMembers.set(hostId, members);
+        }
+        if (node.right instanceof Identifier) {
+            // Alias-like: `export { name }` or `export { name as alias }`.
+            members.push(this.transformBinaryExpressionToExportDeclaration(node, exportName));
+            this.exitDiagnosticContext(scope);
+            return true;
+        }
+        let hasExport = false;
+        for (const member of members)
+            if (member.kind === 279 /* SyntaxKind.ExportDeclaration */)
+                hasExport = true;
+        const variable = this.factory.createVariableStatement(hasExport ? this.factory.createModifierList([this.factory.createToken(94 /* SyntaxKind.ExportKeyword */)]) : undefined, this.factory.createVariableDeclarationList(this.factory.createNodeList([
+            this.factory.createVariableDeclaration(localName, undefined, this.ensureType(node, false), undefined),
+        ]), 0 /* NodeFlags.None */));
+        const statements = [variable];
+        const local = defined(localName);
+        if (local.text !== exportName.text || this.context.hasAutoGenerateInfo(local))
+            statements.push(this.createExportDeclaration(local, exportName));
+        // Members stay exported after an `export {}` is added.
+        if (statements.length > 1 && !hasExport)
+            for (let i = 0; i < members.length; i++)
+                members[i] = this.replaceModifiers(members[i], this.createModifiers(32 /* ModifierFlags.Export */ | getCombinedModifierFlags(members[i])));
+        for (const statement of statements)
+            members.push(statement);
+        this.exitDiagnosticContext(scope);
+        return true;
+    }
+    tryGetPropertyName(node) {
+        if (node instanceof ElementAccessExpression)
+            return this.resolver.getElementAccessExpressionName(node);
+        if (node instanceof PropertyAccessExpression && node.name instanceof Identifier)
+            return node.name.text;
+        return '';
+    }
+    getExpandoHostId(declaration) {
+        const root = declaration instanceof VariableDeclaration ? declaration.parent.parent : declaration;
+        return this.context.mostOriginal(root);
+    }
+    /** The function a property is assigned to, written as a declaration once. */
+    transformExpandoHost(name, declaration) {
+        if (name === undefined)
+            return false;
+        const root = declaration instanceof VariableDeclaration ? declaration.parent.parent : declaration;
+        const id = this.getExpandoHostId(declaration);
+        if (this.expandoHosts.has(id))
+            return false;
+        const saveNeedsDeclare = this.needsDeclare;
+        this.needsDeclare = true;
+        let flags = this.ensureModifierFlags(root);
+        this.needsDeclare = saveNeedsDeclare;
+        const defaultExport = (flags & 32 /* ModifierFlags.Export */) !== 0 && (flags & 2048 /* ModifierFlags.Default */) !== 0;
+        if (defaultExport)
+            flags = (flags | 128 /* ModifierFlags.Ambient */) & ~(2048 /* ModifierFlags.Default */ | 32 /* ModifierFlags.Export */);
+        const scope = this.enterDiagnosticContext(declaration);
+        const modifiers = this.createModifiers(flags);
+        const replacement = [];
+        if (declaration instanceof FunctionDeclaration)
+            replacement.push(defined(this.factory.updateFunctionDeclaration(declaration, modifiers, declaration.asteriskToken, declaration.name, this.ensureTypeParams(declaration, declaration.typeParameters), this.updateParamList(declaration, declaration.parameters), this.ensureType(declaration, false), undefined, undefined)));
+        else if (isFunctionValuedVariable(declaration)) {
+            const fn = getInitializer(declaration);
+            replacement.push(this.factory.created(new FunctionDeclaration(modifiers, asteriskOf(fn), this.factory.createIdentifier(name.text), this.ensureTypeParams(fn, getTypeParameters(fn)), this.updateParamList(fn, getParameters(fn)), this.ensureType(fn, false), undefined, undefined)));
+        }
+        else {
+            this.expandoHosts.set(id, this.transformTopLevelDeclaration(declaration));
+            this.exitDiagnosticContext(scope);
+            return true;
+        }
+        this.tracker.reportExpandoFunctionErrors(declaration);
+        if (defaultExport) {
+            if (declaration.parent !== undefined && declaration.parent.kind === 307 /* SyntaxKind.SourceFile */)
+                this.resultHasExternalModuleIndicator = true;
+            this.resultHasScopeMarker = true;
+            replacement.push(this.factory.created(new ExportAssignment(undefined, false, undefined, name)));
+        }
+        this.expandoHosts.set(id, this.factory.createSyntaxList(replacement));
+        if (this.lateStatementReplacements.has(id))
+            this.lateStatementReplacements.set(id, this.createFullExpandoBlock(id));
+        this.exitDiagnosticContext(scope);
+        return true;
+    }
+    /** A function with its assigned properties as a namespace of the same name. */
+    createFullExpandoBlock(id) {
+        const host = this.expandoHosts.get(id);
+        const addOns = this.expandoMembers.get(id);
+        if (addOns === undefined || host === undefined)
+            return host;
+        let name = undefined;
+        let modifiers = undefined;
+        const statements = host instanceof SyntaxList ? host.children : [host];
+        for (const statement of statements) {
+            const statementName = getName(statement);
+            if (statementName === undefined)
+                continue;
+            name = this.factory.cloneNode(statementName, statementName.deepClone());
+            const statementModifiers = getModifiers(statement);
+            if (statementModifiers !== undefined)
+                modifiers = this.factory.createModifierList(statementModifiers.nodes.slice());
+            break;
+        }
+        if (name === undefined)
+            return host;
+        const result = statements.slice();
+        result.push(this.factory.created(new ModuleDeclaration(modifiers, 145 /* SyntaxKind.NamespaceKeyword */, name, this.factory.created(new ModuleBlock(this.factory.createNodeList(addOns))))));
+        return this.factory.createSyntaxList(result);
+    }
+    /** The `this.x = …` members of a JavaScript class, as property declarations. */
+    collectThisPropertyAssignments(classNode) {
+        const members = getMembers(classNode).nodes;
+        this.seenProperties.clear();
+        for (const member of members) {
+            const name = getName(member);
+            if (name !== undefined)
+                this.seenProperties.add(thisPropertyKey(name, member, isStatic(member)));
+        }
+        this.thisPropertyAssignments = [];
+        const walker = new ThisPropertyWalker(this, classNode);
+        for (const member of members)
+            member.forEachChild(walker);
+        const result = this.thisPropertyAssignments;
+        this.thisPropertyAssignments = [];
+        this.seenProperties.clear();
+        return result;
+    }
+    /** Collects a `this.x = …` assignment of a member of `classNode`. */
+    visitThisPropertyAssignment(node, classNode) {
+        if (getAssignmentDeclarationKind(node) !== 3 /* JSDeclarationKind.ThisProperty */)
+            return false;
+        const container = getThisContainer(node, false, false);
+        if (container.parent !== classNode)
+            return false;
+        const isStaticMember = hasSyntacticModifier(container, 256 /* ModifierFlags.Static */) ||
+            container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */;
+        const assignment = node;
+        let name = getElementOrPropertyAccessName(assignment.left);
+        if (name === undefined)
+            return false;
+        const key = thisPropertyKey(name, node, isStaticMember);
+        if (this.resolver.getReferencedMemberValueDeclaration(node) === undefined || this.seenProperties.has(key))
+            return false;
+        this.seenProperties.add(key);
+        const heritage = getHeritageClauses(classNode);
+        if (heritage !== undefined && heritage.nodes.length > 0 && !isClassExtendingNull(heritage)) {
+            // A base class may provide the member; that needs types.
+            this.tracker.reportInferenceFallback(classNode);
+            if (this.resolver.isThisPropertyAssignmentDeclarationRedundant(node))
+                return false;
+        }
+        if (hasDynamicName(node))
+            return false;
+        if (getTextOfPropertyName(name) === 'constructor')
+            return false;
+        if (name instanceof Identifier && !isIdentifierText(name.text))
+            name = this.factory.createStringLiteralFromNode(name);
+        const property = this.factory.created(new PropertyDeclaration(isStaticMember
+            ? this.factory.createModifierList([this.factory.createToken(125 /* SyntaxKind.StaticKeyword */)])
+            : undefined, name, undefined, this.ensureType(node, false), undefined));
+        if (node.parent !== undefined && node.parent.kind === 245 /* SyntaxKind.ExpressionStatement */)
+            this.context.assignCommentRange(property, node.parent);
+        this.thisPropertyAssignments.push(property);
+        return true;
+    }
+    // Modifiers, types and parameters
+    createModifiers(flags) {
+        const nodes = [];
+        for (const kind of modifierKindsInOrder)
+            if ((flags & modifierToFlag(kind)) !== 0)
+                nodes.push(this.factory.createToken((kind | 0)));
+        return nodes.length === 0 ? undefined : this.factory.createModifierList(nodes);
+    }
+    ensureModifiers(node) {
+        const parseNode = this.parseNode(node);
+        const currentFlags = getCombinedModifierFlags(parseNode) & 131071 /* ModifierFlags.All */;
+        const newFlags = this.ensureModifierFlags(node);
+        if (currentFlags === newFlags) {
+            // Decorators are dropped.
+            const modifiers = getModifiers(node);
+            if (modifiers === undefined)
+                return undefined;
+            let reusable = true;
+            for (const modifier of modifiers.nodes)
+                if (isModifier(modifier) && (modifier.flags & 8 /* NodeFlags.Reparsed */) !== 0) {
+                    reusable = false;
+                    break;
+                }
+            if (reusable) {
+                const kept = [];
+                for (const modifier of modifiers.nodes)
+                    if (isModifier(modifier))
+                        kept.push(modifier);
+                return this.factory.createModifierList(kept);
+            }
+        }
+        return this.createModifiers(newFlags);
+    }
+    ensureModifierFlags(node) {
+        // No `async` or `override` in declaration files, and `public` is implied.
+        let mask = 131071 /* ModifierFlags.All */ ^ (1 /* ModifierFlags.Public */ | 1024 /* ModifierFlags.Async */ | 16 /* ModifierFlags.Override */);
+        let additions = this.needsDeclare && node.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ ? 128 /* ModifierFlags.Ambient */ : 0 /* ModifierFlags.None */;
+        if (node.parent === undefined || node.parent.kind !== 307 /* SyntaxKind.SourceFile */) {
+            mask ^= 128 /* ModifierFlags.Ambient */;
+            additions = 0 /* ModifierFlags.None */;
+        }
+        if (isImplicitlyExportedJSDocDeclaration(node))
+            additions |= 32 /* ModifierFlags.Export */;
+        return maskModifierFlags(node, mask, additions);
+    }
+    ensureTypeParams(node, params) {
+        if (this.isPrivate(this.parseNode(node)))
+            return undefined;
+        const typeParameters = this.visitNodes(params);
+        if (typeParameters !== undefined || getFullSignature(node) === undefined)
+            return typeParameters;
+        // A JSDoc `@type` signature declares the type parameters.
+        const tracker = this.tracker;
+        const oldErrorNameNode = tracker.errorNameNode;
+        tracker.errorNameNode = getName(node);
+        const oldContext = tracker.diagnosticContext;
+        if (!this.suppressNewDiagnosticContexts && canProduceDiagnostics(node))
+            tracker.diagnosticContext = declarationContext(node);
+        const nodes = this.resolver.createTypeParametersOfSignatureDeclaration(this.context, node, this.enclosingDeclaration, 531469 /* NodeBuilderFlags.DeclarationEmit */, tracker);
+        tracker.errorNameNode = oldErrorNameNode;
+        if (!this.suppressNewDiagnosticContexts)
+            tracker.diagnosticContext = oldContext;
+        return nodes === undefined ? undefined : this.factory.createNodeList(nodes);
+    }
+    updateParamList(node, params) {
+        if (this.isPrivate(this.parseNode(node)) || params.nodes.length === 0)
+            return this.factory.createNodeList([]);
+        const results = [];
+        for (const parameter of params.nodes)
+            results.push(this.ensureParameterNode(parameter));
+        return this.factory.createNodeList(results);
+    }
+    ensureParameterNode(node) {
+        if (node === undefined)
+            return node;
+        return node instanceof ParameterDeclaration ? this.ensureParameter(node) : node;
+    }
+    ensureParameter(p) {
+        const tracker = this.tracker;
+        const oldContext = tracker.diagnosticContext;
+        if (!this.suppressNewDiagnosticContexts)
+            tracker.diagnosticContext = declarationContext(p);
+        let questionToken = undefined;
+        if (this.resolver.isOptionalParameter(p))
+            questionToken = p.questionToken ?? this.factory.createToken(57 /* SyntaxKind.QuestionToken */);
+        const result = this.factory.updateParameterDeclaration(p, undefined, p.dotDotDotToken, this.visitBindingName(p.name), questionToken, this.ensureType(p, true), this.ensureNoInitializer(p));
+        tracker.diagnosticContext = oldContext;
+        return result;
+    }
+    visitBindingName(node) {
+        if (node instanceof BindingPattern) {
+            const elements = [];
+            let changed = false;
+            for (const element of node.elements.nodes) {
+                const visited = this.visitBindingName(element);
+                if (visited !== element)
+                    changed = true;
+                elements.push(visited);
+            }
+            return changed
+                ? this.factory.updateBindingPattern(node, new NodeList(node.elements.pos, node.elements.end, elements))
+                : node;
+        }
+        if (node instanceof BindingElement) {
+            const propertyName = node.propertyName;
+            if (propertyName instanceof ComputedPropertyName && isEntityNameExpression(propertyName.expression, false))
+                this.checkEntityNameVisibility(propertyName.expression, this.enclosingDeclaration);
+            return this.factory.updateBindingElement(node, node.dotDotDotToken, propertyName, node.name === undefined ? undefined : this.visitBindingName(node.name), undefined);
+        }
+        return node;
+    }
+    /** The type of a declaration: its annotation, or the resolver's type; `any` if neither. */
+    ensureType(node, ignorePrivate) {
+        // Private declarations have no types, except private parameter properties' parameters.
+        if (!ignorePrivate && this.isPrivate(this.parseNode(node)))
+            return undefined;
+        // Literal constants are written with their initializer instead.
+        if (this.shouldPrintWithInitializer(node))
+            return undefined;
+        const type = getType(node);
+        if (node.kind !== 278 /* SyntaxKind.ExportAssignment */ &&
+            node.kind !== 209 /* SyntaxKind.BindingElement */ &&
+            type !== undefined &&
+            (node.kind !== 170 /* SyntaxKind.Parameter */ ||
+                !this.resolver.requiresAddingImplicitUndefined(node, this.enclosingDeclaration))) {
+            const file = this.tracker.currentSourceFile;
+            if (file === undefined || !file.isJS())
+                return this.visitNode(type);
+            // JSDoc types can need rewriting, which the resolver does.
+            const rewritten = this.resolver.tryJSTypeNodeToTypeNode(this.context, type, this.enclosingDeclaration, this.nodeBuilderFlags(), this.tracker);
+            if (rewritten !== undefined)
+                return rewritten;
+        }
+        const tracker = this.tracker;
+        const oldErrorNameNode = tracker.errorNameNode;
+        tracker.errorNameNode = getName(node);
+        const oldContext = tracker.diagnosticContext;
+        if (!this.suppressNewDiagnosticContexts && canProduceDiagnostics(node))
+            tracker.diagnosticContext = declarationContext(node);
+        let typeNode = undefined;
+        if (hasInferredType(node))
+            typeNode = this.resolver.createTypeOfDeclaration(this.context, node, this.enclosingDeclaration, this.nodeBuilderFlags(), tracker);
+        else if (isFunctionLike(node))
+            typeNode = this.resolver.createReturnTypeOfSignatureDeclaration(this.context, node, this.enclosingDeclaration, this.nodeBuilderFlags(), tracker);
+        tracker.errorNameNode = oldErrorNameNode;
+        if (!this.suppressNewDiagnosticContexts)
+            tracker.diagnosticContext = oldContext;
+        return typeNode ?? this.keyword(132 /* SyntaxKind.AnyKeyword */);
+    }
+    nodeBuilderFlags() {
+        return this.inClassExpressionDeclaration
+            ? 531469 /* NodeBuilderFlags.DeclarationEmit */ & ~2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */
+            : 531469 /* NodeBuilderFlags.DeclarationEmit */;
+    }
+    shouldPrintWithInitializer(node) {
+        return (this.canHaveLiteralInitializer(node) &&
+            getInitializer(node) !== undefined &&
+            this.resolver.isLiteralConstDeclaration(this.context.mostOriginal(node)));
+    }
+    canHaveLiteralInitializer(node) {
+        switch (node.kind) {
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 172 /* SyntaxKind.PropertySignature */:
+                return !this.isPrivate(node);
+            case 170 /* SyntaxKind.Parameter */:
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                return true;
+        }
+        return false;
+    }
+    ensureNoInitializer(node) {
+        if (!this.shouldPrintWithInitializer(node))
+            return undefined;
+        if (!isPrimitiveLiteralValue(skipParenthesesOnly(getInitializer(node)), true))
+            this.tracker.reportInferenceFallback(node);
+        return this.resolver.createLiteralConstValue(this.context, this.parseNode(node), this.tracker);
+    }
+    transformImportEquals(declaration) {
+        if (!this.resolver.isDeclarationVisible(declaration))
+            return undefined;
+        const reference = declaration.moduleReference;
+        if (reference instanceof ExternalModuleReference)
+            return this.factory.updateImportEqualsDeclaration(declaration, declaration.modifiers, declaration.isTypeOnly, declaration.name, this.factory.updateExternalModuleReference(reference, this.rewriteModuleSpecifier(declaration, reference.expression)));
+        const tracker = this.tracker;
+        const oldContext = tracker.diagnosticContext;
+        tracker.diagnosticContext = declarationContext(declaration);
+        this.checkEntityNameVisibility(reference, this.enclosingDeclaration);
+        tracker.diagnosticContext = oldContext;
+        return declaration;
+    }
+    transformImportDeclaration(declaration) {
+        const clause = declaration.importClause;
+        // `import "mod"` may be needed for its side effects, like global augmentations.
+        if (clause === undefined)
+            return this.updateImport(declaration, undefined);
+        const phaseModifier = clause.phaseModifier === 166 /* SyntaxKind.DeferKeyword */ ? undefined : clause.phaseModifier;
+        // The import clause's visibility is the default binding's.
+        const defaultBinding = clause.name !== undefined && this.resolver.isDeclarationVisible(clause) ? clause.name : undefined;
+        const bindings = clause.namedBindings;
+        if (bindings === undefined) {
+            if (defaultBinding === undefined)
+                return undefined;
+            return this.updateImport(declaration, this.factory.updateImportClause(clause, phaseModifier, defaultBinding, undefined));
+        }
+        if (bindings instanceof NamespaceImport) {
+            const namespace = this.resolver.isDeclarationVisible(bindings) ? bindings : undefined;
+            if (defaultBinding === undefined && namespace === undefined)
+                return undefined;
+            return this.updateImport(declaration, this.factory.updateImportClause(clause, phaseModifier, defaultBinding, namespace));
+        }
+        const visibleBindings = [];
+        if (bindings instanceof NamedImports)
+            for (const element of bindings.elements.nodes)
+                if (this.resolver.isDeclarationVisible(element))
+                    visibleBindings.push(element);
+        if (visibleBindings.length > 0 || defaultBinding !== undefined) {
+            const namedImports = visibleBindings.length > 0 && bindings instanceof NamedImports
+                ? this.factory.updateNamedImports(bindings, this.factory.createNodeList(visibleBindings))
+                : undefined;
+            return this.updateImport(declaration, this.factory.updateImportClause(clause, phaseModifier, defaultBinding, namedImports));
+        }
+        // A module augmentation of an export may depend on the import.
+        if (this.resolver.isImportRequiredByAugmentation(declaration)) {
+            if (this.tracker.isolatedDeclarations)
+                this.tracker.addDiagnostic(createDiagnosticForNode(declaration, 1790 /* Diagnostics.Declaration_emit_for_this_file_requires_preserving_this_import_for_augmentations_This_is_not_supported_with_isolatedDeclarations */, []));
+            return this.updateImport(declaration, undefined);
+        }
+        return undefined;
+    }
+    updateImport(declaration, clause) {
+        return this.factory.updateImportDeclaration(declaration, declaration.modifiers, clause, this.rewriteModuleSpecifier(declaration, declaration.moduleSpecifier), this.tryGetResolutionModeOverride(declaration.attributes));
+    }
+    // Visibility helpers
+    parseNode(node) {
+        return this.context.parseNode(node) ?? node;
+    }
+    isPrivate(node) {
+        return this.resolver.getEffectiveDeclarationFlags(node, 2 /* ModifierFlags.Private */) !== 0;
+    }
+    isDeclarationAndNotVisible(node) {
+        const parseNode = this.parseNode(node);
+        switch (parseNode.kind) {
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                return !this.resolver.isDeclarationVisible(parseNode);
+            // These filter their members' visibility themselves.
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                return !this.getBindingNameVisible(parseNode);
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+                return true;
+        }
+        return false;
+    }
+    getBindingNameVisible(element) {
+        if (element.kind === 233 /* SyntaxKind.OmittedExpression */)
+            return false;
+        const name = getName(element);
+        if (name === undefined)
+            return false;
+        if (name instanceof BindingPattern) {
+            // Visible if any element was marked visible, as by referenced aliases.
+            for (const child of name.elements.nodes)
+                if (this.getBindingNameVisible(child))
+                    return true;
+            return false;
+        }
+        return this.resolver.isDeclarationVisible(element);
+    }
+    shouldStripInternal(node) {
+        const file = this.tracker.currentSourceFile;
+        return this.tracker.stripInternal && file !== undefined && this.isInternalDeclaration(node, file);
+    }
+    /** Whether a declaration has an `@internal` comment. */
+    isInternalDeclaration(node, file) {
+        const parseTreeNode = this.context.mostOriginal(node);
+        if ((parseTreeNode.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        const text = file.text;
+        if (parseTreeNode instanceof ParameterDeclaration) {
+            // The comment can precede the parameter or follow the previous one's comma:
+            // `a, /** @internal */ public b: string`.
+            const parameters = getParameters(parseTreeNode.parent).nodes;
+            const index = parameters.indexOf(parseTreeNode);
+            let ranges;
+            if (index > 0) {
+                const trailingPos = skipTrivia(text, parameters[index - 1].end + 1, false, true);
+                ranges = commentRanges(getTrailingCommentRanges(text, trailingPos)).concat(commentRanges(getLeadingCommentRanges(text, node.pos)));
+            }
+            else
+                ranges = commentRanges(getTrailingCommentRanges(text, skipTrivia(text, node.pos, false, true)));
+            return ranges.length > 0 && hasInternalAnnotation(text, ranges[ranges.length - 1]);
+        }
+        if (parseTreeNode.kind === 11 /* SyntaxKind.JsxText */)
+            return false;
+        for (const range of commentRanges(getLeadingCommentRanges(text, parseTreeNode.pos)))
+            if (hasInternalAnnotation(text, range))
+                return true;
+        return false;
+    }
+}
+function commentRanges(ranges) {
+    return ranges ?? [];
+}
+function hasInternalAnnotation(text, range) {
+    return text.substring(range.pos, range.end).indexOf('@internal') >= 0;
+}
+class DiagnosticScope {
+    context;
+    errorNameNode;
+    suppressNewDiagnosticContexts;
+    constructor(context, errorNameNode, suppressNewDiagnosticContexts) {
+        this.context = context;
+        this.errorNameNode = errorNameNode;
+        this.suppressNewDiagnosticContexts = suppressNewDiagnosticContexts;
+    }
+}
+const modifierKindsInOrder = [
+    94 /* SyntaxKind.ExportKeyword */,
+    137 /* SyntaxKind.DeclareKeyword */,
+    89 /* SyntaxKind.DefaultKeyword */,
+    86 /* SyntaxKind.ConstKeyword */,
+    124 /* SyntaxKind.PublicKeyword */,
+    122 /* SyntaxKind.PrivateKeyword */,
+    123 /* SyntaxKind.ProtectedKeyword */,
+    127 /* SyntaxKind.AbstractKeyword */,
+    125 /* SyntaxKind.StaticKeyword */,
+    164 /* SyntaxKind.OverrideKeyword */,
+    148 /* SyntaxKind.ReadonlyKeyword */,
+    128 /* SyntaxKind.AccessorKeyword */,
+    133 /* SyntaxKind.AsyncKeyword */,
+    102 /* SyntaxKind.InKeyword */,
+    147 /* SyntaxKind.OutKeyword */,
+];
+function preservedReferences(references) {
+    const result = [];
+    for (const reference of references)
+        if (reference.preserve)
+            result.push(new FileReference(-1, -1, reference.fileName, reference.resolutionMode, reference.preserve));
+    return result;
+}
+/** Whether a node is a declaration (type parameters only when attached). */
+function isDeclaration(node) {
+    if (node.kind === 169 /* SyntaxKind.TypeParameter */)
+        return node.parent !== undefined;
+    return isDeclarationNode(node);
+}
+function isEntityName(node) {
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+}
+function isThisParameterNode(node) {
+    return node instanceof ParameterDeclaration && node.name instanceof Identifier && node.name.text === 'this';
+}
+/** Declarations whose scope names in their types are resolved from. */
+function isEnclosingDeclaration(node) {
+    switch (node.kind) {
+        case 307 /* SyntaxKind.SourceFile */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 201 /* SyntaxKind.MappedType */:
+        case 261 /* SyntaxKind.VariableDeclaration */:
+            return true;
+    }
+    return isFunctionLike(node);
+}
+function isLateVisibilityPaintedStatement(node) {
+    switch (node.kind) {
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 244 /* SyntaxKind.VariableStatement */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            return true;
+    }
+    return false;
+}
+function isExternalModuleIndicator(node) {
+    return (isAnyImportOrReExport(node) ||
+        node.kind === 278 /* SyntaxKind.ExportAssignment */ ||
+        hasSyntacticModifier(node, 32 /* ModifierFlags.Export */));
+}
+/** Whether a statement in a namespace without `export {}` would stop being exported implicitly. */
+function needsScopeMarker(node) {
+    return (!isAnyImportOrReExport(node) &&
+        node.kind !== 278 /* SyntaxKind.ExportAssignment */ &&
+        !hasSyntacticModifier(node, 32 /* ModifierFlags.Export */) &&
+        !isAmbientModule(node));
+}
+function hasScopeMarker(statements) {
+    for (const statement of statements.nodes)
+        if (statement.kind === 278 /* SyntaxKind.ExportAssignment */ || statement.kind === 279 /* SyntaxKind.ExportDeclaration */)
+            return true;
+    return false;
+}
+function maskModifierFlags(node, mask, additions) {
+    let flags = (getCombinedModifierFlags(node) & mask) | additions;
+    // A default export keeps `export` even where exports are stripped, and never has `declare`.
+    if ((flags & 2048 /* ModifierFlags.Default */) !== 0 && (flags & 32 /* ModifierFlags.Export */) === 0)
+        flags ^= 32 /* ModifierFlags.Export */;
+    if ((flags & 2048 /* ModifierFlags.Default */) !== 0 && (flags & 128 /* ModifierFlags.Ambient */) !== 0)
+        flags ^= 128 /* ModifierFlags.Ambient */;
+    return flags;
+}
+function isImplicitlyExportedJSDocDeclaration(node) {
+    const parent = node.parent;
+    if (parent === undefined || parent.kind !== 307 /* SyntaxKind.SourceFile */)
+        return false;
+    if (!isExternalOrCommonJSModule(parent))
+        return false;
+    if (node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+        return true;
+    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+}
+function canHaveModifiers(node) {
+    switch (node.kind) {
+        case 244 /* SyntaxKind.VariableStatement */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            return true;
+    }
+    return false;
+}
+/** Kinds whose type the resolver writes from the declaration rather than a signature. */
+function hasInferredType(node) {
+    switch (node.kind) {
+        case 170 /* SyntaxKind.Parameter */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 209 /* SyntaxKind.BindingElement */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 333 /* SyntaxKind.JSDocParameterTag */:
+        case 340 /* SyntaxKind.JSDocPropertyTag */:
+            return true;
+    }
+    return false;
+}
+/** A literal that can be an initializer in a declaration file: a string, number, bigint or boolean. */
+function isPrimitiveLiteralValue(node, includeBigInt) {
+    switch (node.kind) {
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return true;
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return includeBigInt;
+        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            const unary = node;
+            const operand = unary.operand;
+            if (unary.operator === 40 /* SyntaxKind.MinusToken */)
+                return operand instanceof NumericLiteral || (includeBigInt && operand.kind === 9 /* SyntaxKind.BigIntLiteral */);
+            if (unary.operator === 39 /* SyntaxKind.PlusToken */)
+                return operand instanceof NumericLiteral;
+            return false;
+        }
+    }
+    return false;
+}
+function skipParenthesesOnly(node) {
+    let current = node;
+    while (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        current = getExpression(current);
+    return current;
+}
+/** Skips what passes an expression's type through: parentheses, assignments and commas. */
+function skipOuterExpressions(node) {
+    let current = node;
+    for (;;) {
+        if (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+            current = getExpression(current);
+        else if (current instanceof BinaryExpression &&
+            (current.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ || current.operatorToken.kind === 27 /* SyntaxKind.CommaToken */))
+            current = current.right;
+        else
+            return current;
+    }
+}
+function getFirstConstructorWithBody(members) {
+    for (const member of members.nodes)
+        if (member !== undefined && member instanceof ConstructorDeclaration && nodeIsPresent(member.body))
+            return member;
+    return undefined;
+}
+function getClassExtendsHeritageElement(node) {
+    const clauses = getHeritageClauses(node);
+    if (clauses === undefined)
+        return undefined;
+    for (const clause of clauses.nodes)
+        if (clause instanceof HeritageClause && clause.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+            const first = clause.types.nodes.length > 0 ? clause.types.nodes[0] : undefined;
+            return first !== undefined && first instanceof ExpressionWithTypeArguments ? first : undefined;
+        }
+    return undefined;
+}
+/** Whether the original of `node` is on one line of its source file. */
+function isOriginalNodeSingleLine(context, node) {
+    const original = context.mostOriginal(node);
+    if ((original.flags & 16 /* NodeFlags.Synthesized */) !== 0 || original.pos < 0)
+        return false;
+    const text = getSourceFileOfNode(original).text;
+    for (let i = original.pos; i < original.end; i++) {
+        const ch = text.charCodeAt(i);
+        if (ch === 10 || ch === 13)
+            return false;
+    }
+    return true;
+}
+/** A node known to be present, checked where its type allows `undefined` at runtime. */
+function defined(node) {
+    if (node === undefined)
+        throw new Error('Expected a node');
+    return node;
+}
+function asteriskOf(fn) {
+    if (fn !== undefined && fn instanceof FunctionExpression)
+        return fn.asteriskToken;
+    return undefined;
+}
+/** `const f = function () {}` or `const f = () => {}`. */
+function isFunctionValuedVariable(node) {
+    if (node.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+        return false;
+    const initializer = getInitializer(node);
+    return (initializer !== undefined &&
+        (initializer.kind === 219 /* SyntaxKind.FunctionExpression */ || initializer.kind === 220 /* SyntaxKind.ArrowFunction */));
+}
+function appendFlattened(result, node) {
+    if (node instanceof SyntaxList)
+        for (const child of node.children)
+            result.push(child);
+    else
+        result.push(node);
+    return true;
+}
+/** The JSDoc `@type` signature of a function-like declaration. */
+function getFullSignature(node) {
+    if (node instanceof FunctionExpression)
+        return node.fullSignature;
+    if (node instanceof ArrowFunction)
+        return node.fullSignature;
+    if (node instanceof FunctionDeclaration)
+        return node.fullSignature;
+    if (node instanceof MethodDeclaration)
+        return node.fullSignature;
+    if (node instanceof ConstructorDeclaration)
+        return node.fullSignature;
+    if (node instanceof GetAccessorDeclaration)
+        return node.fullSignature;
+    if (node instanceof SetAccessorDeclaration)
+        return node.fullSignature;
+    return undefined;
+}
+function isCommonJSAliasExport(node) {
+    if (!(node instanceof BinaryExpression) || !(node.right instanceof Identifier))
+        return false;
+    const symbol = node.symbol;
+    return symbol !== undefined && symbol.declarations.length === 1;
+}
+function getLeftmostAccessExpression(node) {
+    let current = node;
+    while (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || current.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+        current = getExpression(current);
+    return current;
+}
+/** Whether properties assigned to a function are emitted: one of its declarations has a body. */
+function shouldEmitFunctionProperties(fn) {
+    if (fn.body !== undefined)
+        return true;
+    const symbol = fn.symbol;
+    if (symbol === undefined)
+        return false;
+    for (const declaration of symbol.declarations)
+        if (declaration instanceof FunctionDeclaration && declaration.body !== undefined)
+            return true;
+    return false;
+}
+function isNonContextualKeyword(kind) {
+    return (kind >= 82 /* SyntaxKind.FirstKeyword */ &&
+        kind <= 166 /* SyntaxKind.LastKeyword */ &&
+        !(kind >= 127 /* SyntaxKind.FirstContextualKeyword */ && kind <= 166 /* SyntaxKind.LastContextualKeyword */));
+}
+function isClassExtendingNull(heritage) {
+    if (heritage.nodes.length !== 1)
+        return false;
+    for (const type of heritage.nodes[0].types.nodes)
+        if (getExpression(type).kind === 105 /* SyntaxKind.NullKeyword */)
+            return true;
+    return false;
+}
+function getTextOfPropertyName(name) {
+    switch (name.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            return getText(name);
+    }
+    return '';
+}
+/** The key of a class member for deduplicating `this.x` members: name, staticness and privateness. */
+function thisPropertyKey(name, node, isStaticMember) {
+    const prefix = (isStaticMember ? 's' : 'i') + (name instanceof PrivateIdentifier ? '#' : '.');
+    if (!(name instanceof ComputedPropertyName) && name.kind !== 213 /* SyntaxKind.ElementAccessExpression */) {
+        const text = getTextOfPropertyName(name);
+        if (text !== '' || name instanceof StringLiteral)
+            return prefix + text;
+    }
+    return prefix + '@' + node.pos + ':' + node.end;
+}
+/** Walks a whole file for `module.exports =`, assigned properties and CommonJS exports. */
+class ExpressionWalker extends NodeVisitor {
+    transformer;
+    kind;
+    constructor(transformer, kind) {
+        super();
+        this.transformer = transformer;
+        this.kind = kind;
+    }
+    visitNode(node) {
+        // Only assignments and `Object.defineProperty` calls declare anything.
+        if (node.kind === 227 /* SyntaxKind.BinaryExpression */ || node.kind === 214 /* SyntaxKind.CallExpression */) {
+            if (this.kind === 0 /* ExpressionWalkerKind.ModuleExports */)
+                this.transformer.visitModuleExportsAssignment(node);
+            else
+                this.transformer.visitNestedExpression(node);
+        }
+        return node.forEachChild(this);
+    }
+}
+/** Walks a class member for `this.x = …` assignments. */
+class ThisPropertyWalker extends NodeVisitor {
+    transformer;
+    classNode;
+    constructor(transformer, classNode) {
+        super();
+        this.transformer = transformer;
+        this.classNode = classNode;
+    }
+    visitNode(node) {
+        this.transformer.visitThisPropertyAssignment(node, this.classNode);
+        return node.forEachChild(this);
+    }
+}
+/** The text of a JSDoc comment: its text and links, without trailing whitespace. */
+function getTextOfJSDocComment(comment) {
+    if (comment === undefined)
+        return '';
+    let text = '';
+    for (const n of comment.nodes) {
+        if (n instanceof JSDocText)
+            text += n.text;
+        else if (n.kind === 319 /* SyntaxKind.JSDocLink */ ||
+            n.kind === 320 /* SyntaxKind.JSDocLinkCode */ ||
+            n.kind === 321 /* SyntaxKind.JSDocLinkPlain */)
+            text += getSourceTextOfNode(getSourceFileOfNode(n), n);
+    }
+    return text.trimEnd();
+}