tsc-ts 0.0.9 → 0.1.0

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

@@ -3,7 +3,7 @@
 // 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 { getHeritageClauseElementName, 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';
@@ -34,6 +34,8 @@ export class DeclarationTransformer extends Transformer {
     expandoHosts;
     /** The namespace members for the assigned properties of each function, by statement. */
     expandoMembers;
+    /** Assigned properties of hosts that weren't visible when found, by host; written if the host becomes visible. */
+    deferredExpandoAssignments;
     /** The `export =` for a CommonJS `module.exports = …`. */
     cjsExportAssignment;
     /** The exports for CommonJS `exports.x = …` assignments. */
@@ -61,6 +63,7 @@ export class DeclarationTransformer extends Transformer {
         this.lateStatementReplacements = new Map();
         this.expandoHosts = new Map();
         this.expandoMembers = new Map();
+        this.deferredExpandoAssignments = new Map();
         this.cjsExportAssignment = undefined;
         this.cjsExportMembers = [];
         this.cjsExportAssignmentName = undefined;
@@ -73,46 +76,46 @@ export class DeclarationTransformer extends Transformer {
     }
     visit(node) {
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* 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 */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
+            case 245 /* SyntaxKind.VariableStatement */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 279 /* 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 */:
+            case 254 /* SyntaxKind.BreakStatement */:
+            case 253 /* SyntaxKind.ContinueStatement */:
+            case 261 /* SyntaxKind.DebuggerStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
+            case 244 /* SyntaxKind.EmptyStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
+            case 247 /* SyntaxKind.IfStatement */:
+            case 258 /* SyntaxKind.LabeledStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
+            case 257 /* SyntaxKind.SwitchStatement */:
+            case 259 /* SyntaxKind.ThrowStatement */:
+            case 260 /* SyntaxKind.TryStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
+            case 348 /* SyntaxKind.NotEmittedStatement */:
+            case 243 /* SyntaxKind.Block */:
+            case 284 /* SyntaxKind.MissingDeclaration */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 return undefined;
         }
         return this.visitDeclarationSubtree(node);
@@ -130,6 +133,7 @@ export class DeclarationTransformer extends Transformer {
         this.lateStatementReplacements = new Map();
         this.expandoHosts.clear();
         this.expandoMembers.clear();
+        this.deferredExpandoAssignments.clear();
         this.witnessedCjsExports.clear();
         this.cjsExportAssignment = undefined;
         this.cjsExportAssignmentName = undefined;
@@ -173,7 +177,7 @@ export class DeclarationTransformer extends Transformer {
     }
     originalSourceFile(file) {
         const original = this.context.mostOriginal(file);
-        if (original === undefined || original.kind !== 307 /* SyntaxKind.SourceFile */)
+        if (original === undefined || original.kind !== 308 /* SyntaxKind.SourceFile */)
             return file;
         return original;
     }
@@ -195,7 +199,7 @@ export class DeclarationTransformer extends Transformer {
         if (exportEquals === undefined || declarationCount(exportEquals) <= 1)
             return false;
         for (const declaration of getDeclarations(exportEquals))
-            this.tracker.addDiagnostic(createDiagnosticForNode(declaration, 1513 /* Diagnostics.Multiple_module_exports_assignments_cannot_be_serialized_for_declaration_emit */, []));
+            this.tracker.addDiagnostic(createDiagnosticForNode(declaration, 1524 /* Diagnostics.Multiple_module_exports_assignments_cannot_be_serialized_for_declaration_emit */, []));
         return true;
     }
     createEmptyExports() {
@@ -234,7 +238,7 @@ export class DeclarationTransformer extends Transformer {
         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 */;
+            this.needsDeclare = next.parent !== undefined && next.parent.kind === 308 /* SyntaxKind.SourceFile */;
             const result = this.transformTopLevelDeclaration(next);
             this.needsDeclare = saveNeedsDeclare;
             this.lateStatementReplacements.set(this.context.mostOriginal(next), result);
@@ -253,7 +257,7 @@ export class DeclarationTransformer extends Transformer {
             const replacement = this.lateStatementReplacements.get(original);
             if (replacement === undefined)
                 continue;
-            const atTopLevel = statement.parent !== undefined && statement.parent.kind === 307 /* SyntaxKind.SourceFile */;
+            const atTopLevel = statement.parent !== undefined && statement.parent.kind === 308 /* SyntaxKind.SourceFile */;
             if (replacement instanceof SyntaxList) {
                 if (!this.needsScopeFixMarker || !this.resultHasExternalModuleIndicator)
                     for (const child of replacement.children) {
@@ -281,10 +285,10 @@ export class DeclarationTransformer extends Transformer {
         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 */) &&
+        if ((input.kind === 189 /* SyntaxKind.TypeLiteral */ || input.kind === 202 /* SyntaxKind.MappedType */) &&
             input.parent !== undefined &&
-            input.parent.kind !== 266 /* SyntaxKind.TypeAliasDeclaration */ &&
-            input.parent.kind !== 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+            input.parent.kind !== 267 /* SyntaxKind.TypeAliasDeclaration */ &&
+            input.parent.kind !== 346 /* SyntaxKind.JSTypeAliasDeclaration */)
             this.suppressNewDiagnosticContexts = true;
         return scope;
     }
@@ -309,13 +313,13 @@ export class DeclarationTransformer extends Transformer {
                     // 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 */, []));
+                        if (parentKind === 265 /* SyntaxKind.ClassDeclaration */ || parentKind === 212 /* SyntaxKind.ObjectLiteralExpression */) {
+                            this.tracker.addDiagnostic(createDiagnosticForNode(input, 1822 /* 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 */) &&
+                        if ((parentKind === 266 /* SyntaxKind.InterfaceDeclaration */ || parentKind === 189 /* 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 */, []));
+                            this.tracker.addDiagnostic(createDiagnosticForNode(input, 1799 /* Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations */, []));
                             return undefined;
                         }
                     }
@@ -327,7 +331,7 @@ export class DeclarationTransformer extends Transformer {
         // Implementations of overloads are elided.
         if (isFunctionLike(input) && this.resolver.isImplementationOfOverload(input))
             return undefined;
-        if (input.kind === 241 /* SyntaxKind.SemicolonClassElement */)
+        if (input.kind === 242 /* SyntaxKind.SemicolonClassElement */)
             return undefined;
         if (input instanceof HeritageClause) {
             const types = input.types.nodes;
@@ -348,152 +352,159 @@ export class DeclarationTransformer extends Transformer {
     }
     transformDeclarationSubtree(input) {
         switch (input.kind) {
-            case 201 /* SyntaxKind.MappedType */:
+            case 202 /* SyntaxKind.MappedType */:
                 if (input instanceof MappedTypeNode) {
                     const narrowed = input;
                     return this.transformMappedType(narrowed);
                 }
                 break;
-            case 299 /* SyntaxKind.HeritageClause */:
+            case 300 /* SyntaxKind.HeritageClause */:
                 if (input instanceof HeritageClause) {
                     const narrowed = input;
                     return this.transformHeritageClause(narrowed);
                 }
                 break;
-            case 174 /* SyntaxKind.MethodSignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
                 if (input instanceof MethodSignatureDeclaration) {
                     const narrowed = input;
                     return this.transformMethodSignature(narrowed);
                 }
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (input instanceof MethodDeclaration) {
                     const narrowed = input;
                     return this.transformMethodDeclaration(narrowed);
                 }
                 break;
-            case 181 /* SyntaxKind.ConstructSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
                 if (input instanceof ConstructSignatureDeclaration) {
                     const narrowed = input;
                     return this.transformConstructSignature(narrowed);
                 }
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (input instanceof ConstructorDeclaration) {
                     const narrowed = input;
                     return this.transformConstructor(narrowed);
                 }
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (input instanceof GetAccessorDeclaration) {
                     const narrowed = input;
                     return this.transformGetAccessor(narrowed);
                 }
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (input instanceof SetAccessorDeclaration) {
                     const narrowed = input;
                     return this.transformSetAccessor(narrowed);
                 }
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (input instanceof PropertyDeclaration) {
                     const narrowed = input;
                     return this.transformPropertyDeclaration(narrowed);
                 }
                 break;
-            case 172 /* SyntaxKind.PropertySignature */:
+            case 173 /* SyntaxKind.PropertySignature */:
                 if (input instanceof PropertySignatureDeclaration) {
                     const narrowed = input;
                     return this.transformPropertySignature(narrowed);
                 }
                 break;
-            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
                 if (input instanceof CallSignatureDeclaration) {
                     const narrowed = input;
                     return this.transformCallSignature(narrowed);
                 }
                 break;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 if (input instanceof IndexSignatureDeclaration) {
                     const narrowed = input;
                     return this.transformIndexSignature(narrowed);
                 }
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 if (input instanceof VariableDeclaration) {
                     const narrowed = input;
                     return this.transformVariableDeclaration(narrowed);
                 }
                 break;
-            case 169 /* SyntaxKind.TypeParameter */:
+            case 170 /* SyntaxKind.TypeParameter */:
                 if (input instanceof TypeParameterDeclaration) {
                     const narrowed = input;
                     return this.transformTypeParameter(narrowed);
                 }
                 break;
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */: {
+            case 235 /* 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 */:
+            case 185 /* SyntaxKind.TypeReference */:
                 this.checkEntityNameVisibility(input.typeName, this.enclosingDeclaration);
                 return this.visitEachChild(input);
-            case 195 /* SyntaxKind.ConditionalType */:
+            case 196 /* SyntaxKind.ConditionalType */:
                 if (input instanceof ConditionalTypeNode) {
                     const narrowed = input;
                     return this.transformConditionalType(narrowed);
                 }
                 break;
-            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.FunctionType */:
                 if (input instanceof FunctionTypeNode) {
                     const narrowed = input;
                     return this.transformFunctionType(narrowed);
                 }
                 break;
-            case 186 /* SyntaxKind.ConstructorType */:
+            case 187 /* SyntaxKind.ConstructorType */:
                 if (input instanceof ConstructorTypeNode) {
                     const narrowed = input;
                     return this.transformConstructorType(narrowed);
                 }
                 break;
-            case 206 /* SyntaxKind.ImportType */:
+            case 207 /* SyntaxKind.ImportType */:
                 if (input instanceof ImportTypeNode) {
                     const narrowed = input;
                     return this.transformImportType(narrowed);
                 }
                 break;
-            case 187 /* SyntaxKind.TypeQuery */:
+            case 188 /* SyntaxKind.TypeQuery */:
                 this.checkEntityNameVisibility(input.exprName, this.enclosingDeclaration);
                 return this.visitEachChild(input);
-            case 190 /* SyntaxKind.TupleType */: {
+            case 168 /* SyntaxKind.QualifiedName */: {
+                // `typeof this.#x`: the private member isn't in the declaration output.
+                const right = input.right;
+                if (right.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+                    this.tracker.addDiagnostic(createDiagnosticForNode(input, 1752 /* Diagnostics.Declaration_emit_elides_private_members_but_0_refers_to_a_private_member_Write_an_explicit_type_here */, [getText(right)]));
+                return this.visitEachChild(input);
+            }
+            case 191 /* 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 */:
+            case 309 /* SyntaxKind.JSDocTypeExpression */:
                 return this.visitNode(input.type);
-            case 310 /* SyntaxKind.JSDocAllType */:
+            case 311 /* SyntaxKind.JSDocAllType */:
                 return this.replaceWith(input, this.keyword(132 /* SyntaxKind.AnyKeyword */));
-            case 311 /* SyntaxKind.JSDocNullableType */:
+            case 312 /* 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 */:
+            case 313 /* SyntaxKind.JSDocNonNullableType */:
                 return this.visitNode(input.type);
-            case 313 /* SyntaxKind.JSDocOptionalType */:
+            case 314 /* 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 */:
+            case 315 /* SyntaxKind.JSDocVariadicType */:
                 // `...T` is `T[]`.
                 return this.replaceWith(input, this.factory.created(new ArrayTypeNode(this.visitNode(input.type))));
-            case 317 /* SyntaxKind.JSDocTypeLiteral */: {
+            case 318 /* 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 */: {
+            case 341 /* 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)));
@@ -536,9 +547,12 @@ export class DeclarationTransformer extends Transformer {
         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 */))
+            const name = getHeritageClauseElementName(type);
+            if (name.kind === 168 /* SyntaxKind.QualifiedName */ ||
+                isEntityNameExpression(name, false) ||
+                (clause.token === 95 /* SyntaxKind.ExtendsKeyword */ &&
+                    type.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ &&
+                    name.kind === 105 /* SyntaxKind.NullKeyword */))
                 retained.push(type);
         }
         if (retained.length === 0)
@@ -573,7 +587,7 @@ export class DeclarationTransformer extends Transformer {
         // Type parameters of private methods lose their constraints and defaults.
         const parent = input.parent;
         if (parent !== undefined &&
-            parent.kind === 175 /* SyntaxKind.MethodDeclaration */ &&
+            parent.kind === 176 /* SyntaxKind.MethodDeclaration */ &&
             this.isPrivate(parent) &&
             (input.defaultType !== undefined || input.constraint !== undefined))
             return this.factory.updateTypeParameterDeclaration(input, input.modifiers, input.name, undefined, input.expression, undefined);
@@ -585,11 +599,12 @@ export class DeclarationTransformer extends Transformer {
             file.commonJSModuleIndicator !== undefined &&
             isVariableDeclarationInitializedToRequire(input))
             return this.transformCjsRequireVariableDeclaration(input);
-        if (input.name instanceof BindingPattern)
+        // A binding pattern with initializers becomes a declaration per name; without them it stays.
+        if (input.name instanceof BindingPattern && hasAnyBindingInitializers(input.name))
             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));
+        return this.factory.updateVariableDeclaration(input, this.visitBindingName(input.name), undefined, this.ensureType(input, false), this.ensureNoInitializer(input));
     }
     recreateBindingPattern(pattern) {
         const results = [];
@@ -672,7 +687,7 @@ export class DeclarationTransformer extends Transformer {
             if (thisParameter !== undefined)
                 params.push(this.ensureParameterNode(thisParameter));
         }
-        if (input.kind === 179 /* SyntaxKind.SetAccessor */) {
+        if (input.kind === 180 /* SyntaxKind.SetAccessor */) {
             let valueParameter = undefined;
             if (!isPrivate) {
                 if (params.length === 1 && parameters.length >= 2)
@@ -697,7 +712,12 @@ export class DeclarationTransformer extends Transformer {
         const symbol = getSymbol(input);
         if (symbol !== undefined && declarationCount(symbol) > 0 && symbol.declaration !== input)
             return undefined;
-        const result = this.factory.created(new PropertyDeclaration(this.ensureModifiers(input), getName(input), undefined, undefined, undefined));
+        // A method signature becomes a property signature, a method a property declaration.
+        let result;
+        if (input.kind === 175 /* SyntaxKind.MethodSignature */)
+            result = this.factory.created(new PropertySignatureDeclaration(this.ensureModifiers(input), getName(input), undefined, undefined, undefined));
+        else
+            result = this.factory.created(new PropertyDeclaration(this.ensureModifiers(input), getName(input), undefined, undefined, undefined));
         this.context.assignCommentRange(result, input);
         return result;
     }
@@ -722,10 +742,10 @@ export class DeclarationTransformer extends Transformer {
         if (this.shouldStripInternal(input))
             return undefined;
         if (input instanceof ExportDeclaration) {
-            if (input.parent !== undefined && input.parent.kind === 307 /* SyntaxKind.SourceFile */)
+            if (input.parent !== undefined && input.parent.kind === 308 /* 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));
+            return this.factory.updateExportDeclaration(input, input.modifiers, input.isTypeOnly, input.exportClause, this.rewriteModuleSpecifier(input, input.moduleSpecifier), input.attributes);
         }
         if (input instanceof ExportAssignment)
             return this.transformExportAssignment(input, input, input.expression, input.isExportEquals);
@@ -737,33 +757,37 @@ export class DeclarationTransformer extends Transformer {
     }
     /** `export =`, `export default` or `module.exports =` of `expression`. */
     transformExportAssignment(input, assignment, expression, isExportEquals) {
-        if (input.parent !== undefined && input.parent.kind === 307 /* SyntaxKind.SourceFile */)
+        if (input.parent !== undefined && input.parent.kind === 308 /* 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 */)) {
+            (input.parent.kind === 308 /* SyntaxKind.SourceFile */ || input.parent.kind === 270 /* SyntaxKind.ModuleBlock */)) {
             const result = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, expression));
+            this.context.assignSourceMapRange(result, input);
             this.context.assignCommentRange(result, input);
             return result;
         }
+        // Types the default export can't name are reported for it, as class and function declarations too.
+        const tracker = this.tracker;
+        tracker.diagnosticContext = new DiagnosticContext(3 /* DiagnosticContextKind.DefaultExport */, input, undefined);
+        tracker.pushErrorFallbackNode(assignment);
         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.transformFunctionLikeToDeclaration(unwrapped, name, this.declareModifiers(), getType(assignment));
+            tracker.popErrorFallbackNode();
             this.context.assignCommentRange(declaration, input);
             const exportAssignment = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, name));
+            this.context.assignSourceMapRange(exportAssignment, input);
             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);
@@ -772,15 +796,21 @@ export class DeclarationTransformer extends Transformer {
         tracker.popErrorFallbackNode();
         const statement = this.createConstStatement(declaration);
         const exportAssignment = this.factory.created(new ExportAssignment(undefined, isExportEquals, undefined, name));
+        this.context.assignSourceMapRange(exportAssignment, input);
         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));
+    transformFunctionLikeToDeclaration(fn, name, modifiers, fullSignatureType) {
+        // A JSDoc signature, of the function or of the assignment, is reused as the type of a `const`.
+        const fullSignature = getFullSignature(fn) ?? fullSignatureType;
+        if (fullSignature !== undefined)
+            return this.factory.createVariableStatement(modifiers, this.factory.createVariableDeclarationList(this.factory.createNodeList([
+                this.factory.createVariableDeclaration(name, undefined, this.visitNode(fullSignature), undefined),
+            ]), 2 /* NodeFlags.Const */));
+        return this.factory.created(new FunctionDeclaration(modifiers, undefined, name, this.ensureTypeParams(fn, getTypeParameters(fn)), this.updateParamList(fn, getParameters(fn)), this.ensureType(fn, false), undefined, undefined));
     }
     /** A class expression as a declaration, for `export default (class {})` and CommonJS exports. */
     transformClassExpressionToDeclaration(classExpression, name, modifiers) {
@@ -816,7 +846,7 @@ export class DeclarationTransformer extends Transformer {
     /** 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 */) {
+        if (expression.kind !== 213 /* SyntaxKind.PropertyAccessExpression */) {
             const name = getName(expression);
             if (name instanceof Identifier)
                 text = name.text;
@@ -832,15 +862,10 @@ export class DeclarationTransformer extends Transformer {
     rewriteModuleSpecifier(parent, input) {
         if (input === undefined)
             return undefined;
-        if (parent.kind !== 268 /* SyntaxKind.ModuleDeclaration */ && parent.kind !== 206 /* SyntaxKind.ImportType */)
+        if (parent.kind !== 269 /* SyntaxKind.ModuleDeclaration */ && parent.kind !== 207 /* 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)
@@ -863,9 +888,9 @@ export class DeclarationTransformer extends Transformer {
         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 */) {
+            if (result !== undefined && result.kind !== 274 /* 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));
+                const clone = this.factory.created(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, result.modifiers, result.importClause, result.moduleSpecifier, result.attributes));
                 clone.pos = result.pos;
                 clone.end = result.end;
                 this.context.setOriginal(clone, result);
@@ -878,7 +903,7 @@ export class DeclarationTransformer extends Transformer {
         if (isFunctionLike(input) && this.resolver.isImplementationOfOverload(input))
             return undefined;
         const original = this.context.mostOriginal(input);
-        if (this.expandoHosts.has(original))
+        if (this.expandoHosts.has(original) || this.deferredExpandoAssignments.has(original))
             return this.createFullExpandoBlock(original);
         const previousEnclosingDeclaration = this.enclosingDeclaration;
         if (isEnclosingDeclaration(input))
@@ -890,44 +915,44 @@ export class DeclarationTransformer extends Transformer {
         const saveNeedsDeclare = this.needsDeclare;
         let result = undefined;
         switch (input.kind) {
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 if (input instanceof TypeAliasDeclaration) {
                     const narrowed = input;
                     result = this.transformTypeAlias(narrowed);
                 }
                 break;
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
                 if (input instanceof InterfaceDeclaration) {
                     const narrowed = input;
                     result = this.transformInterface(narrowed);
                 }
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 if (input instanceof FunctionDeclaration) {
                     const narrowed = input;
                     result = this.transformFunctionDeclaration(narrowed);
                 }
                 break;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (input instanceof ModuleDeclaration) {
                     const narrowed = input;
                     result = this.transformModuleDeclaration(narrowed);
                 }
                 break;
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 if (input instanceof ClassDeclaration) {
                     const narrowed = input;
                     result = this.transformClassDeclaration(narrowed);
                 }
                 break;
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 if (input instanceof VariableStatement) {
                     const narrowed = input;
                     result = this.transformVariableStatement(narrowed);
                 }
                 break;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (input instanceof EnumDeclaration) {
                     const narrowed = input;
                     result = this.transformEnumDeclaration(narrowed);
@@ -944,7 +969,9 @@ export class DeclarationTransformer extends Transformer {
     }
     transformTypeAlias(input) {
         this.needsDeclare = false;
-        return this.factory.updateTypeAliasDeclaration(input, this.ensureModifiers(input), input.name, this.visitNodes(input.typeParameters), this.visitNode(input.type));
+        return this.factory.updateTypeAliasDeclaration(input, this.ensureModifiers(input), input.name, this.visitNodes(input.typeParameters), 
+        // stripInternal can elide an `@internal` type on the right; it falls back to `any`, as index signatures do.
+        this.visitNode(input.type) ?? this.keyword(132 /* SyntaxKind.AnyKeyword */));
     }
     transformInterface(input) {
         return this.factory.updateInterfaceDeclaration(input, this.ensureModifiers(input), input.name, this.visitNodes(input.typeParameters), this.visitNodes(input.heritageClauses), this.visitNodes(input.members));
@@ -959,6 +986,7 @@ export class DeclarationTransformer extends Transformer {
         const saveNeedsDeclare = this.needsDeclare;
         this.needsDeclare = false;
         const body = input.body;
+        const attributes = this.visitNode(input.attributes);
         let keyword = input.keyword;
         if (keyword !== 162 /* SyntaxKind.GlobalKeyword */ && !(input.name instanceof StringLiteral))
             keyword = 145 /* SyntaxKind.NamespaceKeyword */;
@@ -987,7 +1015,7 @@ export class DeclarationTransformer extends Transformer {
             this.needsDeclare = saveNeedsDeclare;
             this.needsScopeFixMarker = oldNeedsScopeFix;
             this.resultHasScopeMarker = oldHasScopeFix;
-            return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, updatedBody);
+            return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, attributes, updatedBody);
         }
         if (body !== undefined) {
             // A nested `namespace a.b` is transformed now: it needs no visibility painting.
@@ -996,10 +1024,10 @@ export class DeclarationTransformer extends Transformer {
             const inner = this.lateStatementReplacements.get(original);
             this.lateStatementReplacements.delete(original);
             this.needsDeclare = saveNeedsDeclare;
-            return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, inner);
+            return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, attributes, inner);
         }
         this.needsDeclare = saveNeedsDeclare;
-        return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, undefined);
+        return this.factory.updateModuleDeclaration(input, modifiers, keyword, input.name, attributes, undefined);
     }
     stripExportModifiersOfList(list) {
         const nodes = [];
@@ -1015,7 +1043,7 @@ export class DeclarationTransformer extends Transformer {
     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 */ ||
+        if (statement.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ ||
             (parseNode !== undefined && this.resolver.getEffectiveDeclarationFlags(parseNode, 2048 /* ModifierFlags.Default */) !== 0) ||
             !canHaveModifiers(statement))
             return statement;
@@ -1042,7 +1070,7 @@ export class DeclarationTransformer extends Transformer {
         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);
+            return factory.updateModuleDeclaration(node, modifiers, node.keyword, node.name, node.attributes, node.body);
         if (node instanceof ImportDeclaration)
             return factory.updateImportDeclaration(node, modifiers, node.importClause, node.moduleSpecifier, node.attributes);
         if (node instanceof ExportDeclaration)
@@ -1219,8 +1247,8 @@ export class DeclarationTransformer extends Transformer {
             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 */, []));
+                member.name.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
+                this.tracker.addDiagnostic(createDiagnosticForNode(member, 1805 /* 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);
@@ -1253,7 +1281,7 @@ export class DeclarationTransformer extends Transformer {
         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 */)
+        if (!(name instanceof BindingPattern) || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
             return undefined;
         const specifiers = [];
         for (const element of name.elements.nodes) {
@@ -1263,7 +1291,7 @@ export class DeclarationTransformer extends Transformer {
             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));
+        return this.factory.created(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, clause, specifier, undefined));
     }
     /** Finds `module.exports =` assignments anywhere in the file. */
     visitModuleExportsAssignment(node) {
@@ -1354,9 +1382,9 @@ export class DeclarationTransformer extends Transformer {
         const statement = input.parent;
         if (isCommonJSAliasExport(input) &&
             statement !== undefined &&
-            statement.kind === 245 /* SyntaxKind.ExpressionStatement */ &&
+            statement.kind === 246 /* SyntaxKind.ExpressionStatement */ &&
             statement.parent !== undefined &&
-            statement.parent.kind === 307 /* SyntaxKind.SourceFile */)
+            statement.parent.kind === 308 /* SyntaxKind.SourceFile */)
             return this.transformBinaryExpressionToExportDeclaration(input, name);
         if (input instanceof BinaryExpression) {
             const right = skipParenthesesOnly(input.right);
@@ -1419,7 +1447,7 @@ export class DeclarationTransformer extends Transformer {
             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 namespace = factory.created(new ModuleDeclaration(this.declareModifiers(), 145 /* SyntaxKind.NamespaceKeyword */, namespaceName, undefined, 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))));
@@ -1469,7 +1497,7 @@ export class DeclarationTransformer extends Transformer {
         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)))));
+        return this.factory.created(new ModuleDeclaration(this.declareModifiers(), 145 /* SyntaxKind.NamespaceKeyword */, name, undefined, this.factory.created(new ModuleBlock(this.factory.createNodeList(stripped)))));
     }
     stripDeclareModifier(node) {
         const modifiers = getModifiers(node);
@@ -1508,8 +1536,17 @@ export class DeclarationTransformer extends Transformer {
         const property = this.tryGetPropertyName(left);
         if (property === '' || !isIdentifierText(property))
             return false;
-        if (isDeclaration(declaration) && this.isDeclarationAndNotVisible(declaration))
+        const hostId = this.getExpandoHostId(declaration);
+        if (isDeclaration(declaration) && this.isDeclarationAndNotVisible(declaration)) {
+            // Writing the type of a visible declaration, such as `typeof f`, can make the host visible later.
+            let deferred = this.deferredExpandoAssignments.get(hostId);
+            if (deferred === undefined) {
+                deferred = [];
+                this.deferredExpandoAssignments.set(hostId, deferred);
+            }
+            deferred.push(node);
             return false;
+        }
         if (declaration instanceof FunctionDeclaration && !shouldEmitFunctionProperties(declaration))
             return false;
         this.transformExpandoHost(name, declaration);
@@ -1522,23 +1559,24 @@ export class DeclarationTransformer extends Transformer {
             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);
         }
+        let hasExport = false;
+        for (const member of members)
+            if (member.kind === 280 /* SyntaxKind.ExportDeclaration */)
+                hasExport = true;
         if (node.right instanceof Identifier) {
-            // Alias-like: `export { name }` or `export { name as alias }`.
+            // Alias-like: `export { name }` or `export { name as alias }`; the other members stay exported.
+            if (!hasExport)
+                this.addExportModifierToExpandoMembers(members);
             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 */));
@@ -1548,13 +1586,17 @@ export class DeclarationTransformer extends Transformer {
             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])));
+            this.addExportModifierToExpandoMembers(members);
         for (const statement of statements)
             members.push(statement);
         this.exitDiagnosticContext(scope);
         return true;
     }
+    /** Adds `export` to a host's members, before the first `export {}` is added to them. */
+    addExportModifierToExpandoMembers(members) {
+        for (let i = 0; i < members.length; i++)
+            members[i] = this.replaceModifiers(members[i], this.createModifiers(32 /* ModifierFlags.Export */ | getCombinedModifierFlags(members[i])));
+    }
     tryGetPropertyName(node) {
         if (node instanceof ElementAccessExpression)
             return this.resolver.getElementAccessExpressionName(node);
@@ -1597,7 +1639,7 @@ export class DeclarationTransformer extends Transformer {
         }
         this.tracker.reportExpandoFunctionErrors(declaration);
         if (defaultExport) {
-            if (declaration.parent !== undefined && declaration.parent.kind === 307 /* SyntaxKind.SourceFile */)
+            if (declaration.parent !== undefined && declaration.parent.kind === 308 /* SyntaxKind.SourceFile */)
                 this.resultHasExternalModuleIndicator = true;
             this.resultHasScopeMarker = true;
             replacement.push(this.factory.created(new ExportAssignment(undefined, false, undefined, name)));
@@ -1610,6 +1652,13 @@ export class DeclarationTransformer extends Transformer {
     }
     /** A function with its assigned properties as a namespace of the same name. */
     createFullExpandoBlock(id) {
+        // Assignments deferred while the host wasn't visible; they are deferred again if it still isn't.
+        const deferred = this.deferredExpandoAssignments.get(id);
+        if (deferred !== undefined) {
+            this.deferredExpandoAssignments.delete(id);
+            for (const assignment of deferred)
+                this.transformExpandoAssignment(assignment);
+        }
         const host = this.expandoHosts.get(id);
         const addOns = this.expandoMembers.get(id);
         if (addOns === undefined || host === undefined)
@@ -1630,7 +1679,7 @@ export class DeclarationTransformer extends Transformer {
         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))))));
+        result.push(this.factory.created(new ModuleDeclaration(modifiers, 145 /* SyntaxKind.NamespaceKeyword */, name, undefined, 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. */
@@ -1659,7 +1708,7 @@ export class DeclarationTransformer extends Transformer {
         if (container.parent !== classNode)
             return false;
         const isStaticMember = hasSyntacticModifier(container, 256 /* ModifierFlags.Static */) ||
-            container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */;
+            container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */;
         const assignment = node;
         let name = getElementOrPropertyAccessName(assignment.left);
         if (name === undefined)
@@ -1669,7 +1718,7 @@ export class DeclarationTransformer extends Transformer {
             return false;
         this.seenProperties.add(key);
         const heritage = getHeritageClauses(classNode);
-        if (heritage !== undefined && heritage.nodes.length > 0 && !isClassExtendingNull(heritage)) {
+        if (heritage !== undefined && heritage.nodes.length > 0 && !isClassExtendingNull(classNode)) {
             // A base class may provide the member; that needs types.
             this.tracker.reportInferenceFallback(classNode);
             if (this.resolver.isThisPropertyAssignmentDeclarationRedundant(node))
@@ -1681,10 +1730,12 @@ export class DeclarationTransformer extends Transformer {
             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 */)
+        // JSDoc modifiers such as `@readonly` and `@private` apply to the property.
+        let modifierFlags = this.ensureModifierFlags(node);
+        if (isStaticMember)
+            modifierFlags |= 256 /* ModifierFlags.Static */;
+        const property = this.factory.created(new PropertyDeclaration(this.createModifiers(modifierFlags), name, undefined, this.ensureType(node, false), undefined));
+        if (node.parent !== undefined && node.parent.kind === 246 /* SyntaxKind.ExpressionStatement */)
             this.context.assignCommentRange(property, node.parent);
         this.thisPropertyAssignments.push(property);
         return true;
@@ -1725,8 +1776,8 @@ export class DeclarationTransformer extends Transformer {
     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 */) {
+        let additions = this.needsDeclare && node.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ ? 128 /* ModifierFlags.Ambient */ : 0 /* ModifierFlags.None */;
+        if (node.parent === undefined || node.parent.kind !== 308 /* SyntaxKind.SourceFile */) {
             mask ^= 128 /* ModifierFlags.Ambient */;
             additions = 0 /* ModifierFlags.None */;
         }
@@ -1809,10 +1860,10 @@ export class DeclarationTransformer extends Transformer {
         if (this.shouldPrintWithInitializer(node))
             return undefined;
         const type = getType(node);
-        if (node.kind !== 278 /* SyntaxKind.ExportAssignment */ &&
-            node.kind !== 209 /* SyntaxKind.BindingElement */ &&
+        if (node.kind !== 279 /* SyntaxKind.ExportAssignment */ &&
+            node.kind !== 210 /* SyntaxKind.BindingElement */ &&
             type !== undefined &&
-            (node.kind !== 170 /* SyntaxKind.Parameter */ ||
+            (node.kind !== 171 /* SyntaxKind.Parameter */ ||
                 !this.resolver.requiresAddingImplicitUndefined(node, this.enclosingDeclaration))) {
             const file = this.tracker.currentSourceFile;
             if (file === undefined || !file.isJS())
@@ -1850,11 +1901,11 @@ export class DeclarationTransformer extends Transformer {
     }
     canHaveLiteralInitializer(node) {
         switch (node.kind) {
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 172 /* SyntaxKind.PropertySignature */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 173 /* SyntaxKind.PropertySignature */:
                 return !this.isPrivate(node);
-            case 170 /* SyntaxKind.Parameter */:
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 171 /* SyntaxKind.Parameter */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 return true;
         }
         return false;
@@ -1913,13 +1964,13 @@ export class DeclarationTransformer extends Transformer {
         // 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 */, []));
+                this.tracker.addDiagnostic(createDiagnosticForNode(declaration, 1810 /* 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));
+        return this.factory.updateImportDeclaration(declaration, declaration.modifiers, clause, this.rewriteModuleSpecifier(declaration, declaration.moduleSpecifier), declaration.attributes);
     }
     // Visibility helpers
     parseNode(node) {
@@ -1931,24 +1982,24 @@ export class DeclarationTransformer extends Transformer {
     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 */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 return !this.resolver.isDeclarationVisible(parseNode);
             // These filter their members' visibility themselves.
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 return !this.getBindingNameVisible(parseNode);
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 return true;
         }
         return false;
     }
     getBindingNameVisible(element) {
-        if (element.kind === 233 /* SyntaxKind.OmittedExpression */)
+        if (element.kind === 234 /* SyntaxKind.OmittedExpression */)
             return false;
         const name = getName(element);
         if (name === undefined)
@@ -2036,12 +2087,12 @@ function preservedReferences(references) {
 }
 /** Whether a node is a declaration (type parameters only when attached). */
 function isDeclaration(node) {
-    if (node.kind === 169 /* SyntaxKind.TypeParameter */)
+    if (node.kind === 170 /* SyntaxKind.TypeParameter */)
         return node.parent !== undefined;
     return isDeclarationNode(node);
 }
 function isEntityName(node) {
-    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */;
+    return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 168 /* SyntaxKind.QualifiedName */;
 }
 function isThisParameterNode(node) {
     return node instanceof ParameterDeclaration && node.name instanceof Identifier && node.name.text === 'this';
@@ -2049,51 +2100,51 @@ function isThisParameterNode(node) {
 /** 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 */:
+        case 308 /* SyntaxKind.SourceFile */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 202 /* SyntaxKind.MappedType */:
+        case 262 /* 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 */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             return true;
     }
     return false;
 }
 function isExternalModuleIndicator(node) {
     return (isAnyImportOrReExport(node) ||
-        node.kind === 278 /* SyntaxKind.ExportAssignment */ ||
+        node.kind === 279 /* 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 */ &&
+        node.kind !== 279 /* 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 */)
+        if (statement.kind === 279 /* SyntaxKind.ExportAssignment */ || statement.kind === 280 /* SyntaxKind.ExportDeclaration */)
             return true;
     return false;
 }
@@ -2108,28 +2159,28 @@ function maskModifierFlags(node, mask, additions) {
 }
 function isImplicitlyExportedJSDocDeclaration(node) {
     const parent = node.parent;
-    if (parent === undefined || parent.kind !== 307 /* SyntaxKind.SourceFile */)
+    if (parent === undefined || parent.kind !== 308 /* SyntaxKind.SourceFile */)
         return false;
     if (!isExternalOrCommonJSModule(parent))
         return false;
-    if (node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+    if (node.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */)
         return true;
-    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+    return node.kind === 269 /* 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 */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
             return true;
     }
     return false;
@@ -2137,20 +2188,20 @@ function canHaveModifiers(node) {
 /** 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 */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 334 /* SyntaxKind.JSDocParameterTag */:
+        case 341 /* SyntaxKind.JSDocPropertyTag */:
             return true;
     }
     return false;
@@ -2166,7 +2217,7 @@ function isPrimitiveLiteralValue(node, includeBigInt) {
             return true;
         case 9 /* SyntaxKind.BigIntLiteral */:
             return includeBigInt;
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+        case 226 /* SyntaxKind.PrefixUnaryExpression */: {
             const unary = node;
             const operand = unary.operand;
             if (unary.operator === 40 /* SyntaxKind.MinusToken */)
@@ -2180,7 +2231,7 @@ function isPrimitiveLiteralValue(node, includeBigInt) {
 }
 function skipParenthesesOnly(node) {
     let current = node;
-    while (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (current.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         current = getExpression(current);
     return current;
 }
@@ -2188,7 +2239,7 @@ function skipParenthesesOnly(node) {
 function skipOuterExpressions(node) {
     let current = node;
     for (;;) {
-        if (current.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        if (current.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
             current = getExpression(current);
         else if (current instanceof BinaryExpression &&
             (current.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ || current.operatorToken.kind === 27 /* SyntaxKind.CommaToken */))
@@ -2240,11 +2291,11 @@ function asteriskOf(fn) {
 }
 /** `const f = function () {}` or `const f = () => {}`. */
 function isFunctionValuedVariable(node) {
-    if (node.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+    if (node.kind !== 262 /* SyntaxKind.VariableDeclaration */)
         return false;
     const initializer = getInitializer(node);
     return (initializer !== undefined &&
-        (initializer.kind === 219 /* SyntaxKind.FunctionExpression */ || initializer.kind === 220 /* SyntaxKind.ArrowFunction */));
+        (initializer.kind === 220 /* SyntaxKind.FunctionExpression */ || initializer.kind === 221 /* SyntaxKind.ArrowFunction */));
 }
 function appendFlattened(result, node) {
     if (node instanceof SyntaxList)
@@ -2280,7 +2331,7 @@ function isCommonJSAliasExport(node) {
 }
 function getLeftmostAccessExpression(node) {
     let current = node;
-    while (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || current.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+    while (current.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || current.kind === 214 /* SyntaxKind.ElementAccessExpression */)
         current = getExpression(current);
     return current;
 }
@@ -2298,15 +2349,20 @@ function shouldEmitFunctionProperties(fn) {
 }
 function isNonContextualKeyword(kind) {
     return (kind >= 82 /* SyntaxKind.FirstKeyword */ &&
-        kind <= 166 /* SyntaxKind.LastKeyword */ &&
-        !(kind >= 127 /* SyntaxKind.FirstContextualKeyword */ && kind <= 166 /* SyntaxKind.LastContextualKeyword */));
+        kind <= 167 /* SyntaxKind.LastKeyword */ &&
+        !(kind >= 127 /* SyntaxKind.FirstContextualKeyword */ && kind <= 167 /* SyntaxKind.LastContextualKeyword */));
 }
-function isClassExtendingNull(heritage) {
-    if (heritage.nodes.length !== 1)
+/** Whether a class's `extends` clause names exactly `null`. */
+function isClassExtendingNull(node) {
+    const heritage = getHeritageClauses(node);
+    if (heritage === undefined)
         return false;
-    for (const type of heritage.nodes[0].types.nodes)
-        if (getExpression(type).kind === 105 /* SyntaxKind.NullKeyword */)
-            return true;
+    for (const clause of heritage.nodes) {
+        if (clause.token !== 95 /* SyntaxKind.ExtendsKeyword */)
+            continue;
+        const types = clause.types.nodes;
+        return types.length === 1 && getExpression(types[0])?.kind === 105 /* SyntaxKind.NullKeyword */;
+    }
     return false;
 }
 function getTextOfPropertyName(name) {
@@ -2323,7 +2379,7 @@ function getTextOfPropertyName(name) {
 /** 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 */) {
+    if (!(name instanceof ComputedPropertyName) && name.kind !== 214 /* SyntaxKind.ElementAccessExpression */) {
         const text = getTextOfPropertyName(name);
         if (text !== '' || name instanceof StringLiteral)
             return prefix + text;
@@ -2341,7 +2397,7 @@ class ExpressionWalker extends NodeVisitor {
     }
     visitNode(node) {
         // Only assignments and `Object.defineProperty` calls declare anything.
-        if (node.kind === 227 /* SyntaxKind.BinaryExpression */ || node.kind === 214 /* SyntaxKind.CallExpression */) {
+        if (node.kind === 228 /* SyntaxKind.BinaryExpression */ || node.kind === 215 /* SyntaxKind.CallExpression */) {
             if (this.kind === 0 /* ExpressionWalkerKind.ModuleExports */)
                 this.transformer.visitModuleExportsAssignment(node);
             else
@@ -2372,10 +2428,21 @@ function getTextOfJSDocComment(comment) {
     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 */)
+        else if (n.kind === 320 /* SyntaxKind.JSDocLink */ ||
+            n.kind === 321 /* SyntaxKind.JSDocLinkCode */ ||
+            n.kind === 322 /* SyntaxKind.JSDocLinkPlain */)
             text += getSourceTextOfNode(getSourceFileOfNode(n), n);
     }
     return text.trimEnd();
 }
+function hasAnyBindingInitializers(pattern) {
+    for (const element of pattern.elements.nodes) {
+        if (!(element instanceof BindingElement))
+            continue;
+        if (element.initializer !== undefined)
+            return true;
+        if (element.name instanceof BindingPattern && hasAnyBindingInitializers(element.name))
+            return true;
+    }
+    return false;
+}