tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/class-fields.js

@@ -0,0 +1,2418 @@
+// Lowers class fields, private names, static blocks and `accessor` fields: initializers move to
+// the constructor (useDefineForClassFields: false, or targets before ES2022), private members
+// become WeakMaps, WeakSets and hoisted functions, and static `this` and `super` refer to the class.
+import { ArrayLiteralExpression, BinaryExpression, Block, CallExpression, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConstructorDeclaration, ElementAccessExpression, ExportAssignment, ExpressionWithTypeArguments, GetAccessorDeclaration, HeritageClause, Identifier, NodeList, ObjectLiteralExpression, ParameterDeclaration, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, StringLiteral, TryStatement, NewExpression, ArrowFunction, CatchClause, FunctionExpression, MethodDeclaration, NodeVisitor, VoidExpression, getBody, getParameters, getInitializer, getMembers, getModifiers, getName, } from '../ast.js';
+import { isLeftHandSideExpression } from '../ast-utilities.js';
+import { getNameOfDeclaration, hasStaticModifier, isAssignmentExpression, isAutoAccessorPropertyDeclaration, isClassLike, isDestructuringAssignment, isMethodOrAccessor, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from '../binder-utilities.js';
+import { isIdentifierText } from '../scanner.js';
+import { ScriptTarget, getEmitScriptTarget, getUseDefineForClassFields } from '../options.js';
+import { isModifier, isPrologueDirective, isStatement, nodeIsSynthesized } from '../printer/utilities.js';
+import { classHasClassThisAssignment, findSuperStatementIndexPath, getClassMembers, isClassThisAssignmentBlock, } from './class-utilities.js';
+import { AnonymousFunctionFilter, classHasExplicitlyAssignedName, isClassNamedEvaluationHelperBlock, isNamedEvaluation, transformNamedEvaluation, } from './named-evaluation.js';
+import { Transformer } from './transformer.js';
+import { hasDecorators, hasSyntacticModifier, isParameterPropertyDeclaration, isSameNode, skipOuterExpressions, } from './utilities.js';
+import { VisitorBase } from './visitor-base.js';
+/** How a private name is transformed. */
+class PrivateIdentifierInfo {
+    kind;
+    /** The WeakMap of an instance field, the WeakSet of instance methods and accessors, or the class for statics. */
+    brandCheckIdentifier;
+    isStatic;
+    /** False for reserved names such as `#constructor` and duplicates. */
+    isValid;
+    /** The `{ value }` holder of a static field. */
+    variableName;
+    methodName;
+    getterName;
+    setterName;
+    constructor(kind, brandCheckIdentifier, isStatic, isValid) {
+        this.kind = kind;
+        this.brandCheckIdentifier = brandCheckIdentifier;
+        this.isStatic = isStatic;
+        this.isValid = isValid;
+        this.variableName = undefined;
+        this.methodName = undefined;
+        this.getterName = undefined;
+        this.setterName = undefined;
+    }
+}
+/** The private names of a class, by text, and generated private names, by the node they're generated for. */
+class PrivateEnvironment {
+    /** Prefixes generated variable names. */
+    className;
+    /** Brand checks instances for private methods and accessors. */
+    weakSetName;
+    members;
+    generated;
+    constructor() {
+        this.className = undefined;
+        this.weakSetName = undefined;
+        this.members = new Map();
+        this.generated = new Map();
+    }
+}
+class ClassData {
+    facts;
+    /** Brand checks static members and replaces `this` in static initializers. */
+    classConstructor;
+    classThis;
+    /** Replaces `super` in static initializers. */
+    superClassReference;
+    constructor() {
+        this.facts = 0 /* ClassFacts.None */;
+        this.classConstructor = undefined;
+        this.classThis = undefined;
+        this.superClassReference = undefined;
+    }
+}
+class ClassEnvironment {
+    previous;
+    data;
+    privateEnv;
+    constructor(previous) {
+        this.previous = previous;
+        this.data = undefined;
+        this.privateEnv = undefined;
+    }
+}
+class ClassMembers {
+    members;
+    /** An assignment to evaluate before the class, from computed names using `this` or `super`. */
+    prologue;
+    constructor(members, prologue) {
+        this.members = members;
+        this.prologue = prologue;
+    }
+}
+/** A receiver read twice: `read`, assigned by `initialize` first when it had to be cached. */
+class CopiableReceiver {
+    read;
+    initialize;
+    constructor(read, initialize) {
+        this.read = read;
+        this.initialize = initialize;
+    }
+}
+class CallBinding {
+    thisArg;
+    target;
+    constructor(thisArg, target) {
+        this.thisArg = thisArg;
+        this.target = target;
+    }
+}
+/** Visits children in one of the transform's modes. */
+class ModeVisitor extends VisitorBase {
+    owner;
+    mode;
+    constructor(owner, mode) {
+        super(owner.context);
+        this.owner = owner;
+        this.mode = mode;
+    }
+    visit(node) {
+        return this.owner.visitInMode(this.mode, node);
+    }
+}
+const accessorStorageSuffix = '_accessor_storage';
+export class ClassFieldsTransformer extends Transformer {
+    options;
+    facts;
+    resolver;
+    legacyDecorators;
+    useDefineForClassFields;
+    shouldTransformInitializersUsingSet;
+    shouldTransformInitializersUsingDefine;
+    shouldTransformInitializers;
+    shouldTransformPrivateElementsOrClassStaticBlocks;
+    shouldTransformAutoAccessors;
+    /** Static initializers move out of the class body, so their `this` and `super` must name the class. */
+    shouldTransformThisInStaticInitializers;
+    shouldTransformPrivateStaticElementsInFile;
+    /** Computed name expressions from elided names, to inline at the next execution site. */
+    pendingExpressions;
+    /** Statements to emit after the current variable statement, for decorated classes. */
+    pendingStatements;
+    lexicalEnvironment;
+    currentClassContainer;
+    currentClassElement;
+    /** Class declarations to aliases replacing references to the class in its static initializers. */
+    classAliases;
+    enclosingClassDeclarations;
+    inIterationStatement;
+    /** Computed property names evaluate in the scope outside the class. */
+    insideComputedPropertyName;
+    parentNode;
+    currentNode;
+    modifierMode;
+    discarded;
+    heritageMode;
+    assignmentTargetMode;
+    classElementMode;
+    accessorResultMode;
+    arrayElementMode;
+    objectElementMode;
+    substitutionMode;
+    /** Anonymous classes that named evaluation must name here. */
+    classesNeedingNames;
+    constructor(context, options, facts, resolver) {
+        super(context);
+        this.options = options;
+        this.facts = facts;
+        this.resolver = resolver;
+        const target = getEmitScriptTarget(options);
+        const useDefine = getUseDefineForClassFields(options);
+        this.legacyDecorators = options.experimentalDecorators === true;
+        this.useDefineForClassFields = useDefine;
+        this.shouldTransformInitializersUsingSet = !useDefine;
+        this.shouldTransformInitializersUsingDefine = useDefine && target < ScriptTarget.ES2022;
+        this.shouldTransformInitializers =
+            this.shouldTransformInitializersUsingSet || this.shouldTransformInitializersUsingDefine;
+        this.shouldTransformPrivateElementsOrClassStaticBlocks = target < ScriptTarget.ES2022;
+        this.shouldTransformAutoAccessors = target < ScriptTarget.ESNext;
+        this.shouldTransformThisInStaticInitializers = target < ScriptTarget.ES2022;
+        this.shouldTransformPrivateStaticElementsInFile = false;
+        this.pendingExpressions = [];
+        this.pendingStatements = [];
+        this.lexicalEnvironment = undefined;
+        this.currentClassContainer = undefined;
+        this.currentClassElement = undefined;
+        this.classAliases = new Map();
+        this.enclosingClassDeclarations = new Set();
+        this.inIterationStatement = false;
+        this.insideComputedPropertyName = false;
+        this.parentNode = undefined;
+        this.currentNode = undefined;
+        this.modifierMode = new ModeVisitor(this, 0 /* VisitMode.Modifier */);
+        this.discarded = new ModeVisitor(this, 1 /* VisitMode.Discarded */);
+        this.heritageMode = new ModeVisitor(this, 2 /* VisitMode.HeritageClause */);
+        this.assignmentTargetMode = new ModeVisitor(this, 3 /* VisitMode.AssignmentTarget */);
+        this.classElementMode = new ModeVisitor(this, 4 /* VisitMode.ClassElement */);
+        this.accessorResultMode = new ModeVisitor(this, 5 /* VisitMode.AccessorFieldResult */);
+        this.arrayElementMode = new ModeVisitor(this, 6 /* VisitMode.ArrayAssignmentElement */);
+        this.objectElementMode = new ModeVisitor(this, 7 /* VisitMode.ObjectAssignmentElement */);
+        this.substitutionMode = new ModeVisitor(this, 8 /* VisitMode.Substitution */);
+        this.classesNeedingNames = new ClassesNeedingNames(this);
+    }
+    visitInMode(mode, node) {
+        switch (mode) {
+            case 0 /* VisitMode.Modifier */:
+                return this.visitModifier(node);
+            case 1 /* VisitMode.Discarded */:
+                return this.visitDiscardedValue(node);
+            case 2 /* VisitMode.HeritageClause */:
+                return this.visitHeritageClause(node);
+            case 3 /* VisitMode.AssignmentTarget */:
+                if (node instanceof ObjectLiteralExpression || node instanceof ArrayLiteralExpression)
+                    return this.visitAssignmentPattern(node);
+                return this.visit(node);
+            case 4 /* VisitMode.ClassElement */:
+                return this.visitClassElement(node);
+            case 5 /* VisitMode.AccessorFieldResult */:
+                return this.visitAccessorFieldResult(node);
+            case 6 /* VisitMode.ArrayAssignmentElement */:
+                return this.visitArrayAssignmentElement(node);
+            case 7 /* VisitMode.ObjectAssignmentElement */:
+                return this.visitObjectAssignmentElement(node);
+            case 8 /* VisitMode.Substitution */:
+                return this.visitForSubstitution(node);
+        }
+        return node;
+    }
+    /** Whether an auto-accessor, a `#x in` check or a private access needs WeakMaps and WeakSets. */
+    requiresBlockScopedVar() {
+        const container = this.currentClassContainer;
+        return this.inIterationStatement && container !== undefined && container.kind === 232 /* SyntaxKind.ClassExpression */;
+    }
+    /** Whether a class expression's temporary is block scoped: it's in a loop and has an instance field with a computed name. */
+    classExpressionNeedsBlockScopedTemp() {
+        if (!this.requiresBlockScopedVar())
+            return false;
+        const members = membersOf(this.currentClassContainer);
+        for (let i = 0; i < members.length; i++) {
+            const member = members[i];
+            if (member instanceof PropertyDeclaration &&
+                !hasStaticModifier(member) &&
+                member.name instanceof ComputedPropertyName)
+                return true;
+        }
+        return false;
+    }
+    addHoisted(name, blockScoped) {
+        if (blockScoped)
+            this.context.addLexicalDeclaration(name);
+        else
+            this.context.addVariableDeclaration(name);
+        return name;
+    }
+    visitSourceFile(node) {
+        if (node.isDeclarationFile)
+            return node;
+        const context = this.context;
+        this.lexicalEnvironment = undefined;
+        this.shouldTransformPrivateStaticElementsInFile =
+            (context.getEmitFlags(node) & 8388608 /* EmitFlags.TransformPrivateStaticElements */) !== 0;
+        this.classAliases.clear();
+        this.enclosingClassDeclarations.clear();
+        const visited = this.visitEachChild(node);
+        const helpers = context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            context.addEmitHelper(visited, helpers[i]);
+        this.classAliases.clear();
+        this.enclosingClassDeclarations.clear();
+        return visited;
+    }
+    visitModifier(node) {
+        if (node.kind === 128 /* SyntaxKind.AccessorKeyword */)
+            return this.shouldTransformAutoAccessorsInCurrentClass() ? undefined : node;
+        return isModifier(node) ? node : undefined;
+    }
+    /** Substitutes class aliases in subtrees with nothing else to transform, leaving property names alone. */
+    visitForSubstitution(node) {
+        if (node instanceof Identifier)
+            return this.visitIdentifier(node);
+        if (node instanceof PropertyAccessExpression && node.name instanceof Identifier)
+            return this.visitPropertyAccessExpressionForSubstitution(node);
+        return this.substitutionMode.visitEachChild(node);
+    }
+    visit(node) {
+        const grandparent = this.parentNode;
+        this.parentNode = this.currentNode;
+        this.currentNode = node;
+        const result = this.visitWorker(node);
+        this.currentNode = this.parentNode;
+        this.parentNode = grandparent;
+        return result;
+    }
+    visitWorker(node) {
+        if (!this.facts.has(node, 131072 /* SubtreeFacts.ContainsClassFields */ | 6144 /* SubtreeFacts.ContainsLexicalThisOrSuper */)) {
+            if (this.currentClassContainer !== undefined && this.classAliases.size > 0)
+                return this.visitForSubstitution(node);
+            return node;
+        }
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                return this.visitSourceFile(node);
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+                return this.visitClassLike(node);
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                throw new Error('Class elements are visited in class element mode');
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 170 /* SyntaxKind.Parameter */:
+            case 209 /* SyntaxKind.BindingElement */:
+                return this.visitEachChild(this.transformNamedEvaluationIfNeeded(node, ''));
+            case 244 /* SyntaxKind.VariableStatement */:
+                return this.visitVariableStatement(node);
+            case 278 /* SyntaxKind.ExportAssignment */:
+                return this.visitExportAssignment(node);
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+                return this.visitPrivateIdentifier(node);
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                return this.visitPropertyAccessExpression(node);
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                return this.visitElementAccessExpression(node);
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+                return this.visitPreOrPostfixUnaryExpression(node, false);
+            case 227 /* SyntaxKind.BinaryExpression */:
+                return this.visitBinaryExpression(node, false);
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                return this.factory.updateParenthesizedExpression(node, this.visitNode(node.expression));
+            case 214 /* SyntaxKind.CallExpression */:
+                return this.visitCallExpression(node);
+            case 245 /* SyntaxKind.ExpressionStatement */:
+                return this.visitExpressionStatement(node);
+            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+                return this.visitTaggedTemplateExpression(node);
+            case 249 /* SyntaxKind.ForStatement */:
+                return this.visitForStatement(node);
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.WhileStatement */:
+                return this.visitInIteration(node, true);
+            case 109 /* SyntaxKind.ThisKeyword */:
+                return this.visitThisExpression(node);
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+                return this.visitFunctionExpressionOrDeclaration(node);
+            case 177 /* SyntaxKind.Constructor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+                return this.visitInClassElement(node);
+        }
+        return this.visitEachChild(node);
+    }
+    visitInIteration(node, inIteration) {
+        const saved = this.inIterationStatement;
+        this.inIterationStatement = inIteration;
+        const result = this.visitEachChild(node);
+        this.inIterationStatement = saved;
+        return result;
+    }
+    /** Visits the children of a function-like class member with it as the current class element. */
+    visitInClassElement(node) {
+        const savedIteration = this.inIterationStatement;
+        const savedElement = this.currentClassElement;
+        this.inIterationStatement = false;
+        this.currentClassElement = node;
+        const result = this.visitEachChild(node);
+        this.currentClassElement = savedElement;
+        this.inIterationStatement = savedIteration;
+        return result;
+    }
+    /**
+     * Functions get their own `this`, unless synthesized from a static member of the current class,
+     * as the ES decorators transform does for static private auto-accessors.
+     */
+    visitFunctionExpressionOrDeclaration(node) {
+        const savedIteration = this.inIterationStatement;
+        this.inIterationStatement = false;
+        let keepElement = false;
+        const container = this.currentClassContainer;
+        if (this.currentClassElement !== undefined && container !== undefined) {
+            const original = this.context.mostOriginal(node);
+            if (original !== node) {
+                const members = membersOf(container);
+                for (let i = 0; i < members.length; i++)
+                    if (this.context.mostOriginal(members[i]) === original && isStatic(members[i]))
+                        keepElement = true;
+            }
+        }
+        const savedElement = this.currentClassElement;
+        if (!keepElement)
+            this.currentClassElement = undefined;
+        const result = this.visitEachChild(node);
+        this.currentClassElement = savedElement;
+        this.inIterationStatement = savedIteration;
+        return result;
+    }
+    visitDiscardedValue(node) {
+        switch (node.kind) {
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+                return this.visitPreOrPostfixUnaryExpression(node, true);
+            case 227 /* SyntaxKind.BinaryExpression */:
+                return this.visitBinaryExpression(node, true);
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                return this.factory.updateParenthesizedExpression(node, this.discarded.visitNode(node.expression));
+        }
+        return this.visit(node);
+    }
+    visitHeritageClause(node) {
+        if (node instanceof HeritageClause)
+            return this.heritageMode.visitEachChild(node);
+        if (node instanceof ExpressionWithTypeArguments)
+            return this.visitExpressionWithTypeArgumentsInHeritageClause(node);
+        return this.visit(node);
+    }
+    visitClassElement(node) {
+        switch (node.kind) {
+            case 177 /* SyntaxKind.Constructor */: {
+                const saved = this.currentClassElement;
+                this.currentClassElement = node;
+                const container = this.currentClassContainer;
+                const result = container !== undefined
+                    ? this.transformConstructor(node, container)
+                    : this.visitEachChild(node);
+                this.currentClassElement = saved;
+                return result;
+            }
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 175 /* SyntaxKind.MethodDeclaration */: {
+                const saved = this.currentClassElement;
+                this.currentClassElement = node;
+                const result = this.visitMethodOrAccessorDeclaration(node);
+                this.currentClassElement = saved;
+                return result;
+            }
+            case 173 /* SyntaxKind.PropertyDeclaration */: {
+                const saved = this.currentClassElement;
+                this.currentClassElement = node;
+                const result = this.visitPropertyDeclaration(node);
+                this.currentClassElement = saved;
+                return result;
+            }
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */: {
+                const saved = this.currentClassElement;
+                this.currentClassElement = node;
+                const result = this.shouldTransformPrivateElementsOrClassStaticBlocks ? undefined : this.visitEachChild(node);
+                this.currentClassElement = saved;
+                return result;
+            }
+            case 168 /* SyntaxKind.ComputedPropertyName */:
+                return this.visitComputedPropertyName(node);
+            case 241 /* SyntaxKind.SemicolonClassElement */:
+                return node;
+        }
+        if (isModifier(node) || node.kind === 171 /* SyntaxKind.Decorator */)
+            return this.visitModifier(node);
+        return this.visit(node);
+    }
+    visitPropertyName(name) {
+        if (name instanceof ComputedPropertyName)
+            return this.visitComputedPropertyName(name);
+        return this.visitNode(name);
+    }
+    /** Visits the field and accessors an auto-accessor became. */
+    visitAccessorFieldResult(node) {
+        if (node instanceof PropertyDeclaration)
+            return this.transformFieldInitializer(node);
+        if (node instanceof GetAccessorDeclaration || node instanceof SetAccessorDeclaration)
+            return this.visitClassElement(node);
+        throw new Error('Expected a property declaration or accessor');
+    }
+    /** A reference to a class from its static initializers, replaced with the class alias. */
+    visitIdentifier(node) {
+        const declaration = this.resolver.getReferencedValueDeclaration(this.mostOriginalIdentifier(node));
+        if (declaration === undefined)
+            return node;
+        const alias = this.classAliases.get(declaration);
+        if (alias === undefined || !this.enclosingClassDeclarations.has(declaration))
+            return node;
+        const clone = this.factory.cloneIdentifier(alias);
+        this.context.setSourceMapRange(clone, node.pos, node.end);
+        this.context.setCommentRange(clone, node.pos, node.end);
+        return clone;
+    }
+    mostOriginalIdentifier(node) {
+        const original = this.context.mostOriginal(node);
+        return original instanceof Identifier ? original : node;
+    }
+    /** An undeclared private name becomes an empty identifier, except as a statement such as `#;`. */
+    visitPrivateIdentifier(node) {
+        if (!this.shouldTransformPrivateElementsOrClassStaticBlocks)
+            return node;
+        const parent = this.parentNode;
+        if (parent !== undefined && isStatement(parent))
+            return node;
+        const result = this.factory.createIdentifier('');
+        this.context.setOriginal(result, node);
+        return result;
+    }
+    /** `#x in obj` */
+    transformPrivateIdentifierInInExpression(node) {
+        const info = this.accessPrivateIdentifier(node.left);
+        if (info === undefined)
+            return this.visitEachChild(node);
+        const receiver = this.visitNode(node.right);
+        const result = this.factory.createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver);
+        this.context.setOriginal(result, node);
+        return result;
+    }
+    /** An anonymous class whose static members move out of its body, so it can't name itself. */
+    isAnonymousClassNeedingAssignedName(node) {
+        if (!(node instanceof ClassExpression) || node.name !== undefined)
+            return false;
+        const statics = staticPropertiesAndClassStaticBlocks(node);
+        for (let i = 0; i < statics.length; i++)
+            if (isClassNamedEvaluationHelperBlock(this.context, statics[i]))
+                return false;
+        return this.hasTransformableStatics(node, statics);
+    }
+    hasTransformableStatics(node, statics) {
+        if (!this.shouldTransformPrivateElementsOrClassStaticBlocks && !this.hasTransformPrivateStaticElementsFlag(node))
+            return false;
+        for (let i = 0; i < statics.length; i++) {
+            const member = statics[i];
+            if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+                isPrivateIdentifierClassElementDeclaration(member) ||
+                (this.shouldTransformInitializers && isInitializedProperty(member)))
+                return true;
+        }
+        return false;
+    }
+    /** `node`, naming an anonymous class whose static members move out of its body. */
+    transformNamedEvaluationIfNeeded(node, assignedName) {
+        if (!isNamedEvaluation(this.context, node, this.classesNeedingNames))
+            return node;
+        return transformNamedEvaluation(this.context, node, assignedName !== '', assignedName);
+    }
+    visitVariableStatement(node) {
+        const saved = this.pendingStatements;
+        this.pendingStatements = [];
+        const visited = this.visitEachChild(node);
+        const pending = this.pendingStatements;
+        this.pendingStatements = saved;
+        if (pending.length === 0)
+            return visited;
+        return this.factory.createSyntaxList([visited].concat(pending));
+    }
+    visitExportAssignment(node) {
+        let updated = node;
+        if (isNamedEvaluation(this.context, node, this.classesNeedingNames))
+            updated = transformNamedEvaluation(this.context, node, true, node.isExportEquals ? '' : 'default');
+        return this.visitEachChild(updated);
+    }
+    injectPendingExpressions(expression) {
+        if (this.pendingExpressions.length === 0)
+            return expression;
+        const factory = this.factory;
+        let result;
+        if (expression instanceof ParenthesizedExpression) {
+            this.pendingExpressions.push(expression.expression);
+            result = factory.updateParenthesizedExpression(expression, factory.inlineExpressions(this.pendingExpressions));
+        }
+        else {
+            this.pendingExpressions.push(expression);
+            result = factory.inlineExpressions(this.pendingExpressions);
+        }
+        this.pendingExpressions = [];
+        return result;
+    }
+    /** Visits a computed name's expression in the lexical environment outside the class. */
+    visitInOuterEnvironment(expression) {
+        const savedEnvironment = this.lexicalEnvironment;
+        const savedInside = this.insideComputedPropertyName;
+        this.insideComputedPropertyName = true;
+        if (savedEnvironment !== undefined && savedEnvironment.previous !== undefined)
+            this.lexicalEnvironment = savedEnvironment.previous;
+        const visited = this.visitNode(expression);
+        this.lexicalEnvironment = savedEnvironment;
+        this.insideComputedPropertyName = savedInside;
+        return visited;
+    }
+    visitComputedPropertyName(node) {
+        const expression = this.visitInOuterEnvironment(node.expression);
+        return this.factory.updateComputedPropertyName(node, this.injectPendingExpressions(expression));
+    }
+    shouldTransformClassElementToWeakMap(node) {
+        return (this.shouldTransformPrivateElementsOrClassStaticBlocks || this.shouldAlwaysTransformPrivateStaticElements(node));
+    }
+    shouldAlwaysTransformPrivateStaticElements(node) {
+        return hasStaticModifier(node) && this.hasTransformPrivateStaticElementsFlag(node);
+    }
+    hasTransformPrivateStaticElementsFlag(node) {
+        return (this.context.getEmitFlags(node) & 8388608 /* EmitFlags.TransformPrivateStaticElements */) !== 0;
+    }
+    /** A private method or accessor becomes a hoisted function; the member is removed. */
+    visitMethodOrAccessorDeclaration(node) {
+        if (!isPrivateIdentifierClassElementDeclaration(node) || !this.shouldTransformClassElementToWeakMap(node))
+            return this.classElementMode.visitEachChild(node);
+        const info = this.accessPrivateIdentifier(getName(node));
+        if (info === undefined)
+            throw new Error('Undeclared private name for property declaration.');
+        if (!info.isValid)
+            return node;
+        const functionName = this.getHoistedFunctionName(node, info);
+        if (functionName !== undefined) {
+            const factory = this.factory;
+            const modifiers = this.extractModifiers(getModifiers(node), ~(256 /* ModifierFlags.Static */ | 512 /* ModifierFlags.Accessor */));
+            this.context.startVariableEnvironment();
+            const saved = this.inIterationStatement;
+            this.inIterationStatement = false;
+            const body = this.visitFunctionBody(getBody(node));
+            const parameters = this.visitNodes(parametersOf(node));
+            this.inIterationStatement = saved;
+            const asterisk = node instanceof MethodDeclaration ? node.asteriskToken : undefined;
+            const fn = factory.created(new FunctionExpression(modifiers, asterisk, functionName, undefined, parameters, undefined, undefined, body));
+            this.pendingExpressions.push(factory.createAssignment(functionName, fn));
+        }
+        return undefined;
+    }
+    getHoistedFunctionName(node, info) {
+        if (info.kind === 1 /* PrivateKind.Method */)
+            return info.methodName;
+        if (info.kind === 2 /* PrivateKind.Accessor */) {
+            if (node.kind === 178 /* SyntaxKind.GetAccessor */)
+                return info.getterName;
+            if (node.kind === 179 /* SyntaxKind.SetAccessor */)
+                return info.setterName;
+        }
+        return undefined;
+    }
+    /** `this` in a static initializer of the current class: its classThis or constructor alias. */
+    tryGetClassThis() {
+        const classThis = this.tryGetClassThisNoContainer();
+        if (classThis !== undefined)
+            return classThis;
+        const container = this.currentClassContainer;
+        return container !== undefined ? getName(container) : undefined;
+    }
+    tryGetClassThisNoContainer() {
+        const data = this.getClassData();
+        return data.classThis !== undefined ? data.classThis : data.classConstructor;
+    }
+    /** `accessor x = 1` becomes `#x_accessor_storage = 1`, `get x()` and `set x(value)`. */
+    transformAutoAccessor(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const commentPos = context.commentPos(node);
+        const commentEnd = context.commentEnd(node);
+        const sourceMapPos = context.sourceMapPos(node);
+        const sourceMapEnd = context.sourceMapEnd(node);
+        // The getter and setter share one evaluation of a computed name.
+        const name = node.name;
+        let getterName = name;
+        let setterName = name;
+        if (name instanceof ComputedPropertyName && !isSimpleInlineableExpression(name.expression)) {
+            const cacheAssignment = findComputedPropertyNameCacheAssignment(name);
+            if (cacheAssignment !== undefined) {
+                getterName = factory.updateComputedPropertyName(name, this.visitNode(name.expression));
+                setterName = factory.updateComputedPropertyName(name, cacheAssignment.left);
+            }
+            else {
+                const temp = factory.createTempVariable(0);
+                context.setSourceMapRange(temp, name.expression.pos, name.expression.end);
+                context.addVariableDeclaration(temp);
+                const assignment = factory.createAssignment(temp, this.visitNode(name.expression));
+                context.setSourceMapRange(assignment, name.expression.pos, name.expression.end);
+                getterName = factory.updateComputedPropertyName(name, assignment);
+                setterName = factory.updateComputedPropertyName(name, temp);
+            }
+        }
+        const modifiers = this.modifierMode.visitModifiers(node.modifiers);
+        const backingField = factory.updatePropertyDeclaration(node, modifiers, factory.createGeneratedPrivateNameForNode(node.name, '', accessorStorageSuffix), undefined, undefined, node.initializer);
+        context.setOriginal(backingField, node);
+        context.addEmitFlags(backingField, 384 /* EmitFlags.NoComments */);
+        context.setSourceMapRange(backingField, sourceMapPos, sourceMapEnd);
+        let receiver = undefined;
+        if (isStatic(node))
+            receiver = this.tryGetClassThis();
+        if (receiver === undefined)
+            receiver = factory.createThisExpression();
+        const getter = this.createAccessorPropertyGetRedirector(node, modifiers, getterName, receiver);
+        context.setOriginal(getter, node);
+        context.setCommentRange(getter, commentPos, commentEnd);
+        context.setSourceMapRange(getter, sourceMapPos, sourceMapEnd);
+        // Fresh modifiers, so comments aren't duplicated.
+        const setterModifiers = modifiers !== undefined ? factory.createModifiersFromFlags(modifiers.modifierFlags) : undefined;
+        const setter = this.createAccessorPropertySetRedirector(node, setterModifiers, setterName, receiver);
+        context.setOriginal(setter, node);
+        context.addEmitFlags(setter, 384 /* EmitFlags.NoComments */);
+        context.setSourceMapRange(setter, sourceMapPos, sourceMapEnd);
+        return factory.createSyntaxList(this.accessorResultMode.visitArray([backingField, getter, setter]));
+    }
+    transformPrivateFieldInitializer(node) {
+        const factory = this.factory;
+        if (this.shouldTransformClassElementToWeakMap(node)) {
+            // Fields become WeakMaps: the declaration goes.
+            const info = this.accessPrivateIdentifier(node.name);
+            if (info === undefined)
+                throw new Error('Undeclared private name for property declaration.');
+            if (!info.isValid)
+                return node;
+            // A static field of a class whose static blocks stay becomes a static block.
+            if (info.isStatic && !this.shouldTransformPrivateElementsOrClassStaticBlocks) {
+                const statement = this.transformPropertyOrClassStaticBlock(node, factory.createThisExpression());
+                if (statement !== undefined)
+                    return factory.created(new ClassStaticBlockDeclaration(undefined, factory.createBlock([statement], true)));
+            }
+            return undefined;
+        }
+        if (this.shouldTransformInitializersUsingSet &&
+            !hasStaticModifier(node) &&
+            (this.currentClassFacts() & 16 /* ClassFacts.WillHoistInitializersToConstructor */) !== 0)
+            return factory.updatePropertyDeclaration(node, this.visitModifiers(node.modifiers), node.name, undefined, undefined, undefined);
+        const named = this.transformNamedEvaluationIfNeeded(node, '');
+        return factory.updatePropertyDeclaration(named, this.modifierMode.visitModifiers(named.modifiers), this.visitPropertyName(named.name), undefined, undefined, this.visitNode(named.initializer));
+    }
+    transformPublicFieldInitializer(node) {
+        const factory = this.factory;
+        if (this.shouldTransformInitializers && !isAutoAccessorPropertyDeclaration(node)) {
+            // The field goes; its initializer moves to the constructor. A computed name is still evaluated.
+            const expression = this.getPropertyNameExpressionIfNeeded(node.name, node.initializer !== undefined || this.useDefineForClassFields);
+            if (expression !== undefined)
+                flattenCommaList(expression, this.pendingExpressions);
+            // With static blocks kept, a static initializer runs in a static block, where `this` is the class.
+            if (isStatic(node) && !this.shouldTransformPrivateElementsOrClassStaticBlocks) {
+                const statement = this.transformPropertyOrClassStaticBlock(node, factory.createThisExpression());
+                if (statement !== undefined) {
+                    const block = factory.created(new ClassStaticBlockDeclaration(undefined, factory.createBlock([statement], false)));
+                    this.context.setOriginal(block, node);
+                    this.context.setCommentRange(block, node.pos, node.end);
+                    this.context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+                    return block;
+                }
+            }
+            return undefined;
+        }
+        return factory.updatePropertyDeclaration(node, this.modifierMode.visitModifiers(node.modifiers), this.visitPropertyName(node.name), undefined, undefined, this.visitNode(node.initializer));
+    }
+    transformFieldInitializer(node) {
+        if (isPrivateIdentifierClassElementDeclaration(node))
+            return this.transformPrivateFieldInitializer(node);
+        return this.transformPublicFieldInitializer(node);
+    }
+    shouldTransformAutoAccessorsInCurrentClass() {
+        if (this.shouldTransformAutoAccessors)
+            return true;
+        // At ESNext with useDefineForClassFields: false, only when initializers move to the constructor.
+        return (this.currentClassFacts() & 16 /* ClassFacts.WillHoistInitializersToConstructor */) !== 0;
+    }
+    currentClassFacts() {
+        const environment = this.lexicalEnvironment;
+        return environment !== undefined && environment.data !== undefined ? environment.data.facts : 0 /* ClassFacts.None */;
+    }
+    visitPropertyDeclaration(node) {
+        if (isAutoAccessorPropertyDeclaration(node) &&
+            (this.shouldTransformAutoAccessorsInCurrentClass() || this.shouldAlwaysTransformPrivateStaticElements(node)))
+            return this.transformAutoAccessor(node);
+        return this.transformFieldInitializer(node);
+    }
+    createPrivateIdentifierAccess(info, receiver) {
+        return this.createPrivateIdentifierAccessHelper(info, this.visitNode(receiver));
+    }
+    createPrivateIdentifierAccessHelper(info, receiver) {
+        this.context.setCommentRange(receiver, -1, receiver.end);
+        const state = info.brandCheckIdentifier;
+        switch (info.kind) {
+            case 2 /* PrivateKind.Accessor */:
+                return this.factory.createClassPrivateFieldGetHelper(receiver, state, 'a', info.getterName);
+            case 1 /* PrivateKind.Method */:
+                return this.factory.createClassPrivateFieldGetHelper(receiver, state, 'm', info.methodName);
+            case 0 /* PrivateKind.Field */:
+                return this.factory.createClassPrivateFieldGetHelper(receiver, state, 'f', info.isStatic ? info.variableName : undefined);
+        }
+        throw new Error('Access helpers should not be created for untransformed private elements');
+    }
+    /** `super.x` in a static initializer, with the class and its base available. */
+    staticSuperData(node) {
+        const element = this.currentClassElement;
+        const environment = this.lexicalEnvironment;
+        if (!this.shouldTransformThisInStaticInitializers ||
+            element === undefined ||
+            !isSuperProperty(node) ||
+            !isStaticPropertyDeclarationOrClassStaticBlock(element) ||
+            environment === undefined)
+            return undefined;
+        return environment.data;
+    }
+    visitPropertyAccessExpression(node) {
+        const factory = this.factory;
+        if (node.name instanceof PrivateIdentifier) {
+            const info = this.accessPrivateIdentifier(node.name);
+            if (info !== undefined) {
+                const result = this.createPrivateIdentifierAccess(info, node.expression);
+                this.context.setOriginal(result, node);
+                result.pos = node.pos;
+                result.end = node.end;
+                return result;
+            }
+        }
+        const data = node.name instanceof Identifier ? this.staticSuperData(node) : undefined;
+        if (data !== undefined) {
+            if ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0)
+                return this.visitInvalidSuperProperty(node);
+            if (data.classConstructor !== undefined && data.superClassReference !== undefined) {
+                // `super.x` becomes `Reflect.get(_baseTemp, "x", _classTemp)`.
+                const superProperty = factory.createReflectGetCall(data.superClassReference, factory.createStringLiteralFromNode(node.name), data.classConstructor);
+                this.context.setOriginal(superProperty, node.expression);
+                superProperty.pos = node.expression.pos;
+                superProperty.end = node.expression.end;
+                return superProperty;
+            }
+        }
+        // Property names are not references and are never substituted.
+        if (node.name instanceof Identifier)
+            return this.visitPropertyAccessExpressionForSubstitution(node);
+        return this.visitEachChild(node);
+    }
+    visitPropertyAccessExpressionForSubstitution(node) {
+        const expression = this.visitNode(node.expression);
+        if (expression === node.expression)
+            return node;
+        return this.factory.updatePropertyAccessExpression(node, expression, node.questionDotToken, node.name, node.flags);
+    }
+    visitElementAccessExpression(node) {
+        const data = this.staticSuperData(node);
+        if (data !== undefined) {
+            if ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0)
+                return this.visitInvalidSuperProperty(node);
+            if (data.classConstructor !== undefined && data.superClassReference !== undefined) {
+                // `super[x]` becomes `Reflect.get(_baseTemp, x, _classTemp)`.
+                const superProperty = this.factory.createReflectGetCall(data.superClassReference, this.visitNode(node.argumentExpression), data.classConstructor);
+                this.context.setOriginal(superProperty, node.expression);
+                superProperty.pos = node.expression.pos;
+                superProperty.end = node.expression.end;
+                return superProperty;
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    visitPreOrPostfixUnaryExpression(node, discarded) {
+        const factory = this.factory;
+        const context = this.context;
+        const prefix = node instanceof PrefixUnaryExpression;
+        const operator = prefix ? node.operator : node.operator;
+        const operand = prefix ? node.operand : node.operand;
+        if (operator !== 45 /* SyntaxKind.PlusPlusToken */ && operator !== 46 /* SyntaxKind.MinusMinusToken */)
+            return this.visitEachChild(node);
+        const target = skipParentheses(operand);
+        if (target instanceof PropertyAccessExpression && target.name instanceof PrivateIdentifier) {
+            const info = this.accessPrivateIdentifier(target.name);
+            if (info === undefined)
+                return this.visitEachChild(node);
+            const receiver = this.createCopiableReceiver(this.visitNode(target.expression));
+            let expression = this.createPrivateIdentifierAccessHelper(info, receiver.read);
+            let temp = undefined;
+            if (!prefix && !discarded)
+                temp = context.addVariableDeclaration(factory.createTempVariable(0));
+            expression = this.expandIncrementOrDecrement(node, operator, operand, expression, temp);
+            expression = this.createPrivateIdentifierAssignment(info, receiver.initialize !== undefined ? receiver.initialize : receiver.read, expression, 63 /* SyntaxKind.EqualsToken */);
+            context.setOriginal(expression, node);
+            expression.pos = node.pos;
+            expression.end = node.end;
+            if (temp !== undefined)
+                expression = this.withRange(factory.createCommaExpression(expression, temp), node);
+            return expression;
+        }
+        const data = this.staticSuperData(target);
+        if (data === undefined)
+            return this.visitEachChild(node);
+        if ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0) {
+            const visited = this.visitInvalidSuperProperty(target);
+            if (prefix)
+                return factory.updatePrefixUnaryExpression(node, operator, visited);
+            return factory.updatePostfixUnaryExpression(node, visited, operator);
+        }
+        if (data.classConstructor === undefined || data.superClassReference === undefined)
+            return this.visitEachChild(node);
+        // `++super.a` becomes `(Reflect.set(_baseTemp, "a", (_a = Reflect.get(_baseTemp, "a", _classTemp), _b = ++_a), _classTemp), _b)`.
+        let getterName = undefined;
+        let setterName = undefined;
+        if (target instanceof PropertyAccessExpression) {
+            if (target.name instanceof Identifier) {
+                getterName = factory.createStringLiteralFromNode(target.name);
+                setterName = getterName;
+            }
+        }
+        else if (target instanceof ElementAccessExpression) {
+            if (isSimpleInlineableExpression(target.argumentExpression)) {
+                getterName = target.argumentExpression;
+                setterName = getterName;
+            }
+            else {
+                const temp = context.addVariableDeclaration(factory.createTempVariable(0));
+                getterName = temp;
+                setterName = factory.createAssignment(temp, this.visitNode(target.argumentExpression));
+            }
+        }
+        if (getterName === undefined || setterName === undefined)
+            return this.visitEachChild(node);
+        let expression = this.withRange(factory.createReflectGetCall(data.superClassReference, getterName, data.classConstructor), target);
+        let temp = undefined;
+        if (!discarded)
+            temp = context.addVariableDeclaration(factory.createTempVariable(0));
+        expression = this.expandIncrementOrDecrement(node, operator, operand, expression, temp);
+        expression = factory.createReflectSetCall(data.superClassReference, setterName, expression, data.classConstructor);
+        context.setOriginal(expression, node);
+        this.withRange(expression, node);
+        if (temp !== undefined)
+            expression = this.withRange(factory.createCommaExpression(expression, temp), node);
+        return expression;
+    }
+    withRange(node, range) {
+        node.pos = range.pos;
+        node.end = range.end;
+        return node;
+    }
+    /** `(_a = expression, ++_a)`, or `(_a = expression, result = _a++, _a)` for postfix operators. */
+    expandIncrementOrDecrement(node, operator, operand, expression, result) {
+        const factory = this.factory;
+        const temp = this.context.addVariableDeclaration(factory.createTempVariable(0));
+        let value = this.withRange(factory.createAssignment(temp, expression), operand);
+        let operation = node instanceof PrefixUnaryExpression
+            ? factory.createPrefixUnaryExpression(operator, temp)
+            : factory.created(new PostfixUnaryExpression(temp, operator));
+        this.withRange(operation, node);
+        if (result !== undefined)
+            operation = this.withRange(factory.createAssignment(result, operation), node);
+        value = this.withRange(factory.createCommaExpression(value, operation), node);
+        if (node instanceof PostfixUnaryExpression)
+            value = this.withRange(factory.createCommaExpression(value, temp), node);
+        return value;
+    }
+    visitForStatement(node) {
+        const initializer = this.discarded.visitNode(node.initializer);
+        const condition = this.visitNode(node.condition);
+        const incrementor = this.discarded.visitNode(node.incrementor);
+        const saved = this.inIterationStatement;
+        this.inIterationStatement = true;
+        const body = this.visitIterationBody(node.statement);
+        this.inIterationStatement = saved;
+        return this.factory.updateForStatement(node, initializer, condition, incrementor, body);
+    }
+    visitExpressionStatement(node) {
+        // A private name as a statement (`#;`) stays so that it fails at runtime.
+        if (node.expression instanceof PrivateIdentifier && this.shouldTransformPrivateElementsOrClassStaticBlocks)
+            return node;
+        return this.factory.updateExpressionStatement(node, this.discarded.visitNode(node.expression));
+    }
+    createCopiableReceiver(receiver) {
+        const clone = nodeIsSynthesized(receiver) ? receiver : this.shallowClone(receiver);
+        if (isSimpleInlineableExpression(receiver))
+            return new CopiableReceiver(clone, undefined);
+        const read = this.context.addVariableDeclaration(this.factory.createTempVariable(0));
+        return new CopiableReceiver(read, this.factory.createAssignment(read, clone));
+    }
+    /** A copy of `node` sharing its children, which keep generated names. */
+    shallowClone(node) {
+        const factory = this.factory;
+        if (node instanceof Identifier)
+            return factory.cloneIdentifier(node);
+        if (node instanceof PropertyAccessExpression)
+            return factory.cloneNode(node, new PropertyAccessExpression(node.expression, node.questionDotToken, node.name, node.flags));
+        if (node instanceof ElementAccessExpression)
+            return factory.cloneNode(node, new ElementAccessExpression(node.expression, node.questionDotToken, node.argumentExpression, node.flags));
+        if (node instanceof ParenthesizedExpression)
+            return factory.cloneNode(node, new ParenthesizedExpression(node.expression));
+        if (node instanceof CallExpression)
+            return factory.cloneNode(node, new CallExpression(node.expression, node.questionDotToken, node.typeArguments, node.arguments, node.flags));
+        return factory.cloneNode(node, node.deepClone());
+    }
+    visitCallExpression(node) {
+        const factory = this.factory;
+        const callee = node.expression;
+        if (callee instanceof PropertyAccessExpression &&
+            callee.name instanceof PrivateIdentifier &&
+            this.accessPrivateIdentifier(callee.name) !== undefined) {
+            // `obj.#x()` binds `this`: `__classPrivateFieldGet(obj, _C_instances, "m", _C_x).call(obj)`.
+            const binding = this.createCallBinding(callee);
+            const target = this.visitNode(binding.target);
+            const args = [this.visitNode(binding.thisArg)];
+            const visitedArgs = this.visitNodes(node.arguments).nodes;
+            for (let i = 0; i < visitedArgs.length; i++)
+                args.push(visitedArgs[i]);
+            const optional = (node.flags & 32 /* NodeFlags.OptionalChain */) !== 0;
+            const call = factory.created(new PropertyAccessExpression(target, optional ? node.questionDotToken : undefined, factory.createIdentifier('call'), optional ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */));
+            return factory.updateCallExpression(node, call, undefined, undefined, factory.createNodeList(args), node.flags);
+        }
+        const data = this.staticSuperData(callee);
+        if (data !== undefined && data.classConstructor !== undefined) {
+            // `super.f(...)` becomes `Reflect.get(_baseTemp, "f", _classTemp).call(_classTemp, ...)`.
+            const invocation = factory.createFunctionCallCall(this.visitNode(callee), data.classConstructor, this.visitNodes(node.arguments).nodes);
+            this.context.setOriginal(invocation, node);
+            return this.withRange(invocation, node);
+        }
+        return this.visitEachChild(node);
+    }
+    visitTaggedTemplateExpression(node) {
+        const factory = this.factory;
+        const tag = node.tag;
+        if (tag instanceof PropertyAccessExpression &&
+            tag.name instanceof PrivateIdentifier &&
+            this.accessPrivateIdentifier(tag.name) !== undefined) {
+            // A private tag binds `this` with `.bind`.
+            const binding = this.createCallBinding(tag);
+            const bound = factory.createCallExpression(factory.createPropertyAccessExpression(this.visitNode(binding.target), factory.createIdentifier('bind')), [this.visitNode(binding.thisArg)]);
+            return factory.updateTaggedTemplateExpression(node, bound, undefined, undefined, this.visitNode(node.template), node.flags);
+        }
+        const data = this.staticSuperData(tag);
+        if (data !== undefined && data.classConstructor !== undefined) {
+            // `` super.f`x` `` becomes `` Reflect.get(_baseTemp, "f", _classTemp).bind(_classTemp)`x` ``.
+            const invocation = factory.createFunctionBindCall(this.visitNode(tag), data.classConstructor, []);
+            this.context.setOriginal(invocation, node);
+            this.withRange(invocation, node);
+            return factory.updateTaggedTemplateExpression(node, invocation, undefined, undefined, this.visitNode(node.template), node.flags);
+        }
+        return this.visitEachChild(node);
+    }
+    /** A static block as an expression to evaluate after the class: an arrow function called in place. */
+    transformClassStaticBlockDeclaration(node) {
+        if (!this.shouldTransformPrivateElementsOrClassStaticBlocks)
+            return undefined;
+        const context = this.context;
+        const factory = this.factory;
+        if (isClassThisAssignmentBlock(context, node)) {
+            const result = this.visitNode(node.body.statements.nodes[0].expression);
+            // `_classThis = _classThis` does nothing.
+            if (result instanceof BinaryExpression && isAssignmentExpression(result, true) && result.left === result.right)
+                return undefined;
+            return result;
+        }
+        if (isClassNamedEvaluationHelperBlock(context, node))
+            return this.visitNode(node.body.statements.nodes[0].expression);
+        context.startVariableEnvironment();
+        const saved = this.currentClassElement;
+        this.currentClassElement = node;
+        let statements = this.visitArray(node.body.statements.nodes);
+        this.currentClassElement = saved;
+        statements = context.mergeEnvironment(statements, context.endVariableEnvironment());
+        const iife = factory.createImmediatelyInvokedArrowFunction(statements);
+        const arrow = skipParentheses(iife.expression);
+        context.setOriginal(arrow, node);
+        context.addEmitFlags(arrow, 4194304 /* EmitFlags.NoLexicalArguments */);
+        // Keep the statements' range for detached comments, as in `static { // do }`.
+        if (arrow instanceof ArrowFunction && arrow.body instanceof Block) {
+            arrow.body.statements.pos = node.body.statements.pos;
+            arrow.body.statements.end = node.body.statements.end;
+        }
+        context.setOriginal(iife, node);
+        context.assignSourceMapRange(iife, node);
+        context.addEmitFlags(arrow, 16777216 /* EmitFlags.NoLexicalThis */);
+        return iife;
+    }
+    visitBinaryExpression(node, discarded) {
+        const factory = this.factory;
+        const context = this.context;
+        if (isDestructuringAssignment(node)) {
+            // `({ x: obj.#x } = ...)`, `({ x: super.x } = ...)`
+            const saved = this.pendingExpressions;
+            this.pendingExpressions = [];
+            const updated = factory.updateBinaryExpression(node, undefined, this.assignmentTargetMode.visitNode(node.left), undefined, node.operatorToken, this.visitNode(node.right));
+            const pending = this.pendingExpressions;
+            this.pendingExpressions = saved;
+            if (pending.length === 0)
+                return updated;
+            pending.push(updated);
+            return factory.inlineExpressions(pending);
+        }
+        let current = node;
+        if (isAssignmentExpression(node, false)) {
+            const named = this.transformNamedEvaluationIfNeeded(node, '');
+            current = named;
+            const left = skipOuterExpressions(named.left, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */ | 1 /* OuterExpressionKinds.Parentheses */);
+            if (left instanceof PropertyAccessExpression && left.name instanceof PrivateIdentifier) {
+                // `obj.#x = ...`
+                const info = this.accessPrivateIdentifier(left.name);
+                if (info !== undefined) {
+                    const result = this.createPrivateIdentifierAssignment(info, left.expression, named.right, named.operatorToken.kind);
+                    context.setOriginal(result, named);
+                    return this.withRange(result, named);
+                }
+            }
+            else {
+                const data = this.staticSuperData(named.left);
+                if (data !== undefined) {
+                    if ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0)
+                        return factory.updateBinaryExpression(named, undefined, this.visitInvalidSuperProperty(named.left), undefined, named.operatorToken, this.visitNode(named.right));
+                    if (data.classConstructor !== undefined && data.superClassReference !== undefined) {
+                        const assigned = this.transformSuperPropertyAssignment(named, data, discarded);
+                        if (assigned !== undefined)
+                            return assigned;
+                    }
+                }
+            }
+        }
+        if (current.operatorToken.kind === 102 /* SyntaxKind.InKeyword */ && current.left instanceof PrivateIdentifier)
+            return this.transformPrivateIdentifierInInExpression(current);
+        return this.visitEachChild(current);
+    }
+    /** `super.x = 1` becomes `(Reflect.set(_baseTemp, "x", _a = 1, _classTemp), _a)`. */
+    transformSuperPropertyAssignment(node, data, discarded) {
+        const factory = this.factory;
+        const context = this.context;
+        const left = node.left;
+        let setterName = undefined;
+        if (left instanceof ElementAccessExpression)
+            setterName = this.visitNode(left.argumentExpression);
+        else if (left instanceof PropertyAccessExpression && left.name instanceof Identifier)
+            setterName = factory.createStringLiteralFromNode(left.name);
+        if (setterName === undefined)
+            return undefined;
+        const superClass = data.superClassReference;
+        const classConstructor = data.classConstructor;
+        let expression = this.visitNode(node.right);
+        const operator = node.operatorToken.kind;
+        if (isCompoundAssignment(operator)) {
+            let getterName = setterName;
+            if (!isSimpleInlineableExpression(setterName)) {
+                const temp = context.addVariableDeclaration(factory.createTempVariable(0));
+                getterName = temp;
+                setterName = factory.createAssignment(temp, setterName);
+            }
+            const get = factory.createReflectGetCall(superClass, getterName, classConstructor);
+            context.setOriginal(get, left);
+            this.withRange(get, left);
+            expression = this.withRange(factory.createBinaryExpression(get, nonAssignmentOperatorForCompoundAssignment(operator), expression), node);
+        }
+        let temp = undefined;
+        if (!discarded) {
+            temp = context.addVariableDeclaration(factory.createTempVariable(0));
+            expression = this.withRange(factory.createAssignment(temp, expression), node);
+        }
+        expression = factory.createReflectSetCall(superClass, setterName, expression, classConstructor);
+        context.setOriginal(expression, node);
+        this.withRange(expression, node);
+        if (temp !== undefined)
+            expression = this.withRange(factory.createCommaExpression(expression, temp), node);
+        return expression;
+    }
+    createPrivateIdentifierAssignment(info, receiverExpression, rightExpression, operator) {
+        const factory = this.factory;
+        let receiver = this.visitNode(receiverExpression);
+        let right = this.visitNode(rightExpression);
+        if (isCompoundAssignment(operator)) {
+            const copiable = this.createCopiableReceiver(receiver);
+            receiver = copiable.initialize !== undefined ? copiable.initialize : copiable.read;
+            right = factory.createBinaryExpression(this.createPrivateIdentifierAccessHelper(info, copiable.read), nonAssignmentOperatorForCompoundAssignment(operator), right);
+        }
+        this.context.setCommentRange(receiver, -1, receiver.end);
+        const state = info.brandCheckIdentifier;
+        switch (info.kind) {
+            case 2 /* PrivateKind.Accessor */:
+                return factory.createClassPrivateFieldSetHelper(receiver, state, right, 'a', info.setterName);
+            case 1 /* PrivateKind.Method */:
+                return factory.createClassPrivateFieldSetHelper(receiver, state, right, 'm', undefined);
+            case 0 /* PrivateKind.Field */:
+                return factory.createClassPrivateFieldSetHelper(receiver, state, right, 'f', info.isStatic ? info.variableName : undefined);
+        }
+        throw new Error('Access helpers should not be created for untransformed private elements');
+    }
+    /**
+     * Whether the body or initializer of `member` refers to the class `classNode` by name, which then
+     * needs an alias once the member's code moves out of the class.
+     */
+    memberContainsConstructorReference(member, classNode) {
+        const finder = new ConstructorReferenceFinder(this.resolver, this.context.mostOriginal(classNode), getNameOfDeclaration(classNode));
+        const body = member instanceof ClassStaticBlockDeclaration ? member.body : getBody(member);
+        if (body !== undefined && finder.check(body))
+            return true;
+        if (member instanceof PropertyDeclaration && member.initializer !== undefined && finder.check(member.initializer))
+            return true;
+        return false;
+    }
+    classContainsConstructorReference(node) {
+        const members = membersOf(node);
+        for (let i = 0; i < members.length; i++)
+            if (this.memberContainsConstructorReference(members[i], node))
+                return true;
+        return false;
+    }
+    getClassFacts(node) {
+        const context = this.context;
+        let facts = 0 /* ClassFacts.None */;
+        const original = context.mostOriginal(node);
+        if (isClassLike(original) && classOrConstructorParameterIsDecorated(this.legacyDecorators, original))
+            facts |= 1 /* ClassFacts.ClassWasDecorated */;
+        const members = membersOf(node);
+        if (this.shouldTransformPrivateElementsOrClassStaticBlocks &&
+            (classHasClassThisAssignment(context, getClassMembers(node)) || classHasExplicitlyAssignedName(context, node)))
+            facts |= 2 /* ClassFacts.NeedsClassConstructorReference */;
+        let containsPublicInstanceFields = false;
+        let containsInitializedPublicInstanceFields = false;
+        let containsInstancePrivateElements = false;
+        let containsInstanceAutoAccessors = false;
+        for (let i = 0; i < members.length; i++) {
+            const member = members[i];
+            const name = getName(member);
+            if (isStatic(member)) {
+                if (name !== undefined &&
+                    (name.kind === 80 /* SyntaxKind.PrivateIdentifier */ || isAutoAccessorPropertyDeclaration(member)) &&
+                    this.shouldTransformPrivateElementsOrClassStaticBlocks)
+                    facts |= 2 /* ClassFacts.NeedsClassConstructorReference */;
+                else if (isAutoAccessorPropertyDeclaration(member) &&
+                    this.shouldTransformAutoAccessors &&
+                    getName(node) === undefined &&
+                    context.getClassThis(node) === undefined)
+                    facts |= 2 /* ClassFacts.NeedsClassConstructorReference */;
+                if (member instanceof PropertyDeclaration || member instanceof ClassStaticBlockDeclaration) {
+                    if (this.shouldTransformThisInStaticInitializers &&
+                        this.facts.has(member, 2048 /* SubtreeFacts.ContainsLexicalThis */)) {
+                        facts |= 8 /* ClassFacts.NeedsSubstitutionForThisInClassStaticField */;
+                        if ((facts & 1 /* ClassFacts.ClassWasDecorated */) === 0)
+                            facts |= 2 /* ClassFacts.NeedsClassConstructorReference */;
+                    }
+                    if (this.shouldTransformThisInStaticInitializers &&
+                        this.facts.has(member, 4096 /* SubtreeFacts.ContainsLexicalSuper */) &&
+                        (facts & 1 /* ClassFacts.ClassWasDecorated */) === 0)
+                        facts |= 2 /* ClassFacts.NeedsClassConstructorReference */ | 4 /* ClassFacts.NeedsClassSuperReference */;
+                }
+            }
+            else if (!hasSyntacticModifier(context.mostOriginal(member), 64 /* ModifierFlags.Abstract */)) {
+                if (isAutoAccessorPropertyDeclaration(member)) {
+                    containsInstanceAutoAccessors = true;
+                    if (isPrivateIdentifierClassElementDeclaration(member))
+                        containsInstancePrivateElements = true;
+                }
+                else if (isPrivateIdentifierClassElementDeclaration(member)) {
+                    containsInstancePrivateElements = true;
+                    if (this.memberContainsConstructorReference(member, node))
+                        facts |= 2 /* ClassFacts.NeedsClassConstructorReference */;
+                }
+                else if (member instanceof PropertyDeclaration) {
+                    containsPublicInstanceFields = true;
+                    if (member.initializer !== undefined)
+                        containsInitializedPublicInstanceFields = true;
+                }
+            }
+        }
+        const transformPrivate = this.shouldTransformPrivateElementsOrClassStaticBlocks;
+        if ((this.shouldTransformInitializersUsingDefine && containsPublicInstanceFields) ||
+            (this.shouldTransformInitializersUsingSet && containsInitializedPublicInstanceFields) ||
+            (transformPrivate && containsInstancePrivateElements) ||
+            (transformPrivate && containsInstanceAutoAccessors && this.shouldTransformAutoAccessors))
+            facts |= 16 /* ClassFacts.WillHoistInitializersToConstructor */;
+        return facts;
+    }
+    visitExpressionWithTypeArgumentsInHeritageClause(node) {
+        if ((this.currentClassFacts() & 4 /* ClassFacts.NeedsClassSuperReference */) !== 0) {
+            const factory = this.factory;
+            const temp = this.context.addVariableDeclaration(factory.createTempVariable(8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */));
+            this.getClassData().superClassReference = temp;
+            return factory.updateExpressionWithTypeArguments(node, factory.createAssignment(temp, this.visitNode(node.expression)), undefined);
+        }
+        return this.heritageMode.visitEachChild(node);
+    }
+    /** Visits a class in a new class lexical environment. */
+    visitClassLike(node) {
+        const savedContainer = this.currentClassContainer;
+        const savedPending = this.pendingExpressions;
+        const savedEnvironment = this.lexicalEnvironment;
+        this.currentClassContainer = node;
+        this.pendingExpressions = [];
+        this.lexicalEnvironment = new ClassEnvironment(savedEnvironment);
+        const context = this.context;
+        const original = context.mostOriginal(node);
+        this.enclosingClassDeclarations.add(original);
+        if (this.shouldTransformPrivateElementsOrClassStaticBlocks || this.hasTransformPrivateStaticElementsFlag(node)) {
+            const name = getNameOfDeclaration(node);
+            if (name instanceof Identifier)
+                this.getPrivateEnvironment().className = name;
+            else {
+                const assignedName = context.getAssignedName(node);
+                if (assignedName instanceof StringLiteral) {
+                    const textSource = context.getTextSource(assignedName);
+                    if (textSource instanceof Identifier)
+                        this.getPrivateEnvironment().className = textSource;
+                    else if (isIdentifierText(assignedName.text))
+                        this.getPrivateEnvironment().className = this.factory.createIdentifier(assignedName.text);
+                }
+            }
+        }
+        if (this.shouldTransformPrivateElementsOrClassStaticBlocks) {
+            const methods = privateInstanceMethodsAndAccessors(node);
+            if (methods.length > 0)
+                this.getPrivateEnvironment().weakSetName = this.createHoistedVariableForClass('instances', getName(methods[0]), '');
+        }
+        const facts = this.getClassFacts(node);
+        if (facts !== 0 /* ClassFacts.None */)
+            this.getClassData().facts = facts;
+        const result = node instanceof ClassDeclaration
+            ? this.visitClassDeclarationInEnvironment(node, facts)
+            : this.visitClassExpressionInEnvironment(node, facts);
+        this.enclosingClassDeclarations.delete(original);
+        this.currentClassContainer = savedContainer;
+        this.pendingExpressions = savedPending;
+        this.lexicalEnvironment = savedEnvironment;
+        return result;
+    }
+    visitClassDeclarationInEnvironment(node, facts) {
+        const factory = this.factory;
+        const context = this.context;
+        // Private statics and static `this` or `super` need a reference to the class.
+        let pendingClassReferenceAssignment = undefined;
+        const classThis = classThisOf(context, node);
+        if ((facts & 2 /* ClassFacts.NeedsClassConstructorReference */) !== 0) {
+            // Reusing `_classThis` is only safe when static blocks are transformed too: the assignment
+            // then runs before them, so it doesn't overwrite a replacement constructor from decorators.
+            if (this.shouldTransformPrivateElementsOrClassStaticBlocks && classThis !== undefined) {
+                this.getClassData().classConstructor = classThis;
+                pendingClassReferenceAssignment = factory.createAssignment(classThis, factory.getLocalName(node, 0 /* NameOptions.None */));
+            }
+            else {
+                const temp = context.addVariableDeclaration(factory.createTempVariable(8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */));
+                this.getClassData().classConstructor = factory.cloneIdentifier(temp);
+                pendingClassReferenceAssignment = factory.createAssignment(temp, factory.getLocalName(node, 0 /* NameOptions.None */));
+            }
+        }
+        if (classThis !== undefined)
+            this.getClassData().classThis = classThis;
+        // Aliases are registered before visiting members, which substitute eagerly.
+        const alias = this.getClassData().classConstructor;
+        if (alias !== undefined && this.classContainsConstructorReference(node))
+            this.classAliases.set(context.mostOriginal(node), alias);
+        let modifiers = this.modifierMode.visitModifiers(node.modifiers);
+        const heritageClauses = this.heritageMode.visitNodes(node.heritageClauses);
+        const transformed = this.transformClassMembers(node);
+        const statements = [];
+        if (pendingClassReferenceAssignment !== undefined)
+            this.pendingExpressions.unshift(pendingClassReferenceAssignment);
+        // Expressions from elided or moved computed property names.
+        if (this.pendingExpressions.length > 0)
+            statements.push(factory.createExpressionStatement(factory.inlineExpressions(this.pendingExpressions)));
+        let name = node.name;
+        if (this.shouldTransformInitializersUsingSet || this.shouldTransformPrivateElementsOrClassStaticBlocks) {
+            // Static initializers run after the class, which is safe because the declaration is lexical.
+            const statics = staticPropertiesAndClassStaticBlocks(node);
+            if (statics.length > 0) {
+                if (name === undefined)
+                    name = factory.createGeneratedNameForNode(node, 0, '', '');
+                this.addPropertyOrClassStaticBlockStatements(statements, statics, factory.getLocalName(node, 0 /* NameOptions.None */));
+            }
+        }
+        if (statements.length > 0 &&
+            hasSyntacticModifier(node, 32 /* ModifierFlags.Export */) &&
+            hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */)) {
+            modifiers = this.extractModifiers(modifiers, ~(32 /* ModifierFlags.Export */ | 2048 /* ModifierFlags.Default */));
+            statements.push(factory.created(new ExportAssignment(undefined, false, undefined, factory.getLocalName(node, 0 /* NameOptions.None */))));
+        }
+        const updated = factory.updateClassDeclaration(node, modifiers, name, undefined, heritageClauses, transformed.members);
+        const result = [];
+        if (transformed.prologue !== undefined)
+            result.push(factory.createExpressionStatement(transformed.prologue));
+        result.push(updated);
+        for (let i = 0; i < statements.length; i++)
+            result.push(statements[i]);
+        return factory.createSyntaxList(result);
+    }
+    createClassTemp() {
+        const temp = this.factory.createTempVariable(8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */);
+        return temp;
+    }
+    visitClassExpressionInEnvironment(node, facts) {
+        const factory = this.factory;
+        const context = this.context;
+        // A class expression from a decorated class declaration puts its statics in statements after
+        // the variable statement, as the declaration would.
+        const isDecoratedClassDeclaration = (facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0;
+        const classThis = classThisOf(context, node);
+        if (classThis !== undefined)
+            this.getClassData().classThis = classThis;
+        let temp = undefined;
+        if ((facts & 2 /* ClassFacts.NeedsClassConstructorReference */) !== 0) {
+            if ((this.shouldTransformPrivateElementsOrClassStaticBlocks || this.hasTransformPrivateStaticElementsFlag(node)) &&
+                classThis !== undefined) {
+                this.getClassData().classConstructor = classThis;
+                temp = classThis;
+            }
+            else {
+                temp = this.addHoisted(this.createClassTemp(), this.classExpressionNeedsBlockScopedTemp());
+                this.getClassData().classConstructor = factory.cloneIdentifier(temp);
+            }
+        }
+        const statics = staticPropertiesAndClassStaticBlocks(node);
+        // Aliases must be known before visiting members, so predict whether a temporary will wrap the class.
+        let isClassWithConstructorReference = false;
+        let hasTransformableStatics = false;
+        let deferTempDeclaration = false;
+        if (!isDecoratedClassDeclaration) {
+            isClassWithConstructorReference = this.classContainsConstructorReference(node);
+            hasTransformableStatics = this.hasTransformableStatics(node, statics);
+            let willHavePrivatePendingExpressions = false;
+            if (this.shouldTransformPrivateElementsOrClassStaticBlocks) {
+                const members = node.members.nodes;
+                for (let i = 0; i < members.length; i++) {
+                    const member = members[i];
+                    if (isPrivateIdentifierClassElementDeclaration(member) &&
+                        !hasStaticModifier(member) &&
+                        this.shouldTransformClassElementToWeakMap(member)) {
+                        willHavePrivatePendingExpressions = true;
+                        break;
+                    }
+                }
+            }
+            const willNeedTempWrapper = hasTransformableStatics || willHavePrivatePendingExpressions;
+            if (isClassWithConstructorReference &&
+                willNeedTempWrapper &&
+                this.getClassData().classConstructor === undefined) {
+                // Declared after the members are visited, to keep tsc's declaration order.
+                temp = this.createClassTemp();
+                deferTempDeclaration = true;
+                this.getClassData().classConstructor = factory.cloneIdentifier(temp);
+            }
+            const alias = this.getClassData().classConstructor;
+            if (isClassWithConstructorReference && willNeedTempWrapper && alias !== undefined)
+                this.classAliases.set(context.mostOriginal(node), alias);
+        }
+        const modifiers = this.modifierMode.visitModifiers(node.modifiers);
+        const heritageClauses = this.heritageMode.visitNodes(node.heritageClauses);
+        const transformed = this.transformClassMembers(node);
+        if (deferTempDeclaration)
+            this.addHoisted(temp, this.classExpressionNeedsBlockScopedTemp());
+        const classExpression = factory.updateClassExpression(node, modifiers, node.name, undefined, heritageClauses, transformed.members);
+        const expressions = [];
+        if (transformed.prologue !== undefined)
+            expressions.push(transformed.prologue);
+        if (!isDecoratedClassDeclaration) {
+            if (hasTransformableStatics || this.pendingExpressions.length > 0) {
+                if (temp === undefined) {
+                    temp = this.addHoisted(this.createClassTemp(), this.classExpressionNeedsBlockScopedTemp());
+                    const alias = factory.cloneIdentifier(temp);
+                    this.getClassData().classConstructor = alias;
+                    if (isClassWithConstructorReference)
+                        this.classAliases.set(context.mostOriginal(node), alias);
+                }
+                expressions.push(factory.createAssignment(temp, classExpression));
+                // Expressions left from elided or moved computed property names.
+                for (let i = 0; i < this.pendingExpressions.length; i++)
+                    expressions.push(this.pendingExpressions[i]);
+                const initializers = this.generateInitializedPropertyExpressionsOrClassStaticBlock(statics, temp);
+                for (let i = 0; i < initializers.length; i++)
+                    expressions.push(initializers[i]);
+                expressions.push(factory.cloneIdentifier(temp));
+            }
+            else
+                expressions.push(classExpression);
+        }
+        else {
+            for (let i = 0; i < this.pendingExpressions.length; i++)
+                this.pendingStatements.push(factory.createExpressionStatement(this.pendingExpressions[i]));
+            if (statics.length > 0) {
+                const receiver = classThis !== undefined ? classThis : factory.getLocalName(node, 0 /* NameOptions.None */);
+                this.addPropertyOrClassStaticBlockStatements(this.pendingStatements, statics, receiver);
+            }
+            if (temp !== undefined)
+                expressions.push(factory.createAssignment(temp, classExpression));
+            else if (this.shouldTransformPrivateElementsOrClassStaticBlocks && classThis !== undefined)
+                expressions.push(factory.createAssignment(classThis, classExpression));
+            else
+                expressions.push(classExpression);
+        }
+        if (expressions.length > 1) {
+            context.addEmitFlags(classExpression, 8192 /* EmitFlags.Indented */);
+            for (let i = 0; i < expressions.length; i++)
+                context.addEmitFlags(expressions[i], 524288 /* EmitFlags.StartOnNewLine */);
+        }
+        return factory.inlineExpressions(expressions);
+    }
+    /** `this` in a static initializer, or a computed name, of a class whose code moves out of its body. */
+    visitThisExpression(node) {
+        const environment = this.lexicalEnvironment;
+        if (environment === undefined || environment.data === undefined || !this.shouldTransformThisInStaticInitializers)
+            return node;
+        const data = environment.data;
+        // Computed names of ES-decorated classes are already in an arrow function seeing the outer `this`.
+        if (this.insideComputedPropertyName &&
+            ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) === 0 || this.legacyDecorators)) {
+            const classThis = this.tryGetClassThisNoContainer();
+            if (classThis !== undefined)
+                return classThis;
+        }
+        const element = this.currentClassElement;
+        if (element !== undefined && isStaticPropertyDeclarationOrClassStaticBlock(element)) {
+            const classThis = this.tryGetClassThisNoContainer();
+            if (classThis !== undefined)
+                return classThis;
+            // A legacy decorator may replace the class, so `this` can't name it.
+            if ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0 && this.legacyDecorators)
+                return this.factory.createParenthesizedExpression(this.factory.createVoidZero());
+        }
+        return node;
+    }
+    transformClassMembers(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const memberList = getMembers(node);
+        const memberNodes = memberList.nodes;
+        const privateStaticsInClass = this.hasTransformPrivateStaticElementsFlag(node);
+        // Declare private names.
+        if (this.shouldTransformPrivateElementsOrClassStaticBlocks || this.shouldTransformPrivateStaticElementsInFile) {
+            for (let i = 0; i < memberNodes.length; i++) {
+                const member = memberNodes[i];
+                if (!isPrivateIdentifierClassElementDeclaration(member))
+                    continue;
+                if (this.shouldTransformClassElementToWeakMap(member))
+                    this.addPrivateIdentifierToEnvironment(member);
+                else
+                    this.setPrivateIdentifier(this.getPrivateEnvironment(), getName(member), new PrivateIdentifierInfo(3 /* PrivateKind.Untransformed */, undefined, false, false));
+            }
+            if (this.shouldTransformPrivateElementsOrClassStaticBlocks && privateInstanceMethodsAndAccessors(node).length > 0)
+                this.createBrandCheckWeakSetForPrivateMethods(this.getPrivateEnvironment());
+            if (this.shouldTransformAutoAccessorsInCurrentClass()) {
+                for (let i = 0; i < memberNodes.length; i++) {
+                    const member = memberNodes[i];
+                    if (!isAutoAccessorPropertyDeclaration(member))
+                        continue;
+                    const storageName = factory.createGeneratedPrivateNameForNode(getName(member), '', accessorStorageSuffix);
+                    if (this.shouldTransformPrivateElementsOrClassStaticBlocks ||
+                        (privateStaticsInClass && hasStaticModifier(member)))
+                        this.addPrivateIdentifierPropertyDeclarationToEnvironment(member, storageName);
+                    else {
+                        // Unless the first loop declared it, as for a private auto-accessor expanded by ES decorators.
+                        const environment = this.getPrivateEnvironment();
+                        if (this.getPrivateIdentifier(environment, storageName) === undefined)
+                            this.setPrivateIdentifier(environment, storageName, new PrivateIdentifierInfo(3 /* PrivateKind.Untransformed */, undefined, false, false));
+                    }
+                }
+            }
+        }
+        let members = this.classElementMode.visitNodes(memberList);
+        let syntheticConstructor = undefined;
+        let hasConstructor = false;
+        for (let i = 0; i < members.nodes.length; i++)
+            if (members.nodes[i].kind === 177 /* SyntaxKind.Constructor */)
+                hasConstructor = true;
+        if (!hasConstructor)
+            syntheticConstructor = this.transformConstructor(undefined, node);
+        // Without static blocks transformed, computed name expressions are evaluated in a static block
+        // at the top of the class, before other static initializers.
+        let syntheticStaticBlock = undefined;
+        let prologue = undefined;
+        if (!this.shouldTransformPrivateElementsOrClassStaticBlocks && this.pendingExpressions.length > 0) {
+            let statement = factory.createExpressionStatement(factory.inlineExpressions(this.pendingExpressions));
+            if (this.facts.has(statement, 6144 /* SubtreeFacts.ContainsLexicalThisOrSuper */)) {
+                // `this` and `super` in computed names refer to the outer scope: evaluate them in an arrow function.
+                const temp = context.addVariableDeclaration(factory.createTempVariable(0));
+                const arrow = factory.createArrowFunction([], factory.createBlock([statement], false));
+                prologue = factory.createAssignment(temp, arrow);
+                statement = factory.createExpressionStatement(factory.createCallExpression(temp, []));
+            }
+            syntheticStaticBlock = factory.created(new ClassStaticBlockDeclaration(undefined, factory.createBlock([statement], false)));
+            this.pendingExpressions = [];
+        }
+        if (syntheticConstructor !== undefined || syntheticStaticBlock !== undefined) {
+            // The classThis and named evaluation blocks stay first.
+            const nodes = members.nodes;
+            let classThisIndex = -1;
+            let namedEvaluationIndex = -1;
+            for (let i = 0; i < nodes.length; i++)
+                if (classThisIndex < 0 && isClassThisAssignmentBlock(context, nodes[i]))
+                    classThisIndex = i;
+            for (let i = 0; i < nodes.length; i++)
+                if (namedEvaluationIndex < 0 && isClassNamedEvaluationHelperBlock(context, nodes[i]))
+                    namedEvaluationIndex = i;
+            const updated = [];
+            if (classThisIndex >= 0)
+                updated.push(nodes[classThisIndex]);
+            if (namedEvaluationIndex >= 0)
+                updated.push(nodes[namedEvaluationIndex]);
+            if (syntheticConstructor !== undefined)
+                updated.push(syntheticConstructor);
+            if (syntheticStaticBlock !== undefined)
+                updated.push(syntheticStaticBlock);
+            for (let i = 0; i < nodes.length; i++)
+                if (i !== classThisIndex && i !== namedEvaluationIndex)
+                    updated.push(nodes[i]);
+            members = new NodeList(memberList.pos, memberList.end, updated);
+        }
+        return new ClassMembers(members, prologue);
+    }
+    createBrandCheckWeakSetForPrivateMethods(environment) {
+        const factory = this.factory;
+        this.pendingExpressions.push(factory.createAssignment(environment.weakSetName, factory.created(new NewExpression(factory.createIdentifier('WeakSet'), undefined, factory.createNodeList([])))));
+        return true;
+    }
+    transformConstructor(constructor, container) {
+        // Parameters and body are visited in the scopes of the new body, so hoisted variables come first.
+        if ((this.currentClassFacts() & 16 /* ClassFacts.WillHoistInitializersToConstructor */) === 0)
+            return constructor !== undefined ? this.visitEachChild(constructor) : undefined;
+        const extendsElement = getClassExtendsHeritageElement(container);
+        const isDerivedClass = extendsElement !== undefined &&
+            skipOuterExpressions(extendsElement.expression, 63 /* OuterExpressionKinds.All */).kind !== 105 /* SyntaxKind.NullKeyword */;
+        const parameters = constructor !== undefined ? this.visitNodes(constructor.parameters) : undefined;
+        const body = this.transformConstructorBody(container, constructor, isDerivedClass);
+        if (body === undefined)
+            return constructor !== undefined ? this.visitEachChild(constructor) : undefined;
+        const factory = this.factory;
+        if (constructor !== undefined)
+            return factory.updateConstructorDeclaration(constructor, undefined, undefined, parameters, undefined, undefined, body);
+        const result = factory.created(new ConstructorDeclaration(undefined, undefined, factory.createNodeList([]), undefined, undefined, body));
+        return this.withRange(result, container);
+    }
+    transformConstructorBodyWorker(statementsOut, statementsIn, start, superPath, depth, initializerStatements, constructor) {
+        const superIndex = superPath[depth] | 0;
+        const superStatement = statementsIn[superIndex];
+        appendAll(statementsOut, this.visitArray(statementsIn.slice(start, superIndex)));
+        let offset = superIndex + 1;
+        if (superStatement instanceof TryStatement) {
+            const tryBlock = superStatement.tryBlock;
+            const inner = this.transformConstructorBodyWorker([], tryBlock.statements.nodes, 0, superPath, depth + 1, initializerStatements, constructor);
+            const list = new NodeList(tryBlock.statements.pos, tryBlock.statements.end, inner);
+            const catchClause = this.visitNode(superStatement.catchClause);
+            const finallyBlock = this.visitNode(superStatement.finallyBlock);
+            statementsOut.push(this.factory.updateTryStatement(superStatement, this.factory.updateBlock(tryBlock, list, tryBlock.multiLine), catchClause instanceof CatchClause ? catchClause : undefined, finallyBlock instanceof Block ? finallyBlock : undefined));
+        }
+        else {
+            appendAll(statementsOut, this.visitArray([superStatement]));
+            // Parameter property assignments directly follow `super()`; initializers go after them.
+            offset = this.skipParameterPropertyAssignments(statementsIn, offset, constructor);
+            appendAll(statementsOut, initializerStatements);
+        }
+        appendAll(statementsOut, this.visitArray(statementsIn.slice(offset)));
+        return statementsOut;
+    }
+    skipParameterPropertyAssignments(statements, start, constructor) {
+        let offset = start;
+        while (offset < statements.length &&
+            isParameterPropertyDeclaration(this.context.mostOriginal(statements[offset]), constructor))
+            offset++;
+        return offset;
+    }
+    transformConstructorBody(container, constructor, isDerivedClass) {
+        const factory = this.factory;
+        const context = this.context;
+        const instanceProperties = propertiesOf(container, false);
+        let properties = instanceProperties;
+        if (!this.useDefineForClassFields)
+            properties = withInitializerOrPrivateName(properties);
+        const privateMethodsAndAccessors = privateInstanceMethodsAndAccessors(container);
+        const needsConstructorBody = properties.length > 0 || privateMethodsAndAccessors.length > 0;
+        if (constructor === undefined && !needsConstructorBody)
+            return this.visitFunctionBody(undefined);
+        context.startVariableEnvironment();
+        const needsSyntheticConstructor = constructor === undefined && isDerivedClass;
+        let statements = [];
+        const initializerStatements = [];
+        const receiver = factory.createThisExpression();
+        // Private methods can be called in initializers, so their brand comes first.
+        this.addInstanceMethodStatements(initializerStatements, privateMethodsAndAccessors, receiver);
+        if (constructor !== undefined) {
+            const parameterProperties = [];
+            const others = [];
+            for (let i = 0; i < instanceProperties.length; i++)
+                if (isParameterPropertyDeclaration(context.mostOriginal(instanceProperties[i]), constructor))
+                    parameterProperties.push(instanceProperties[i]);
+            for (let i = 0; i < properties.length; i++)
+                if (!isParameterPropertyDeclaration(context.mostOriginal(properties[i]), constructor))
+                    others.push(properties[i]);
+            this.addPropertyOrClassStaticBlockStatements(initializerStatements, parameterProperties, receiver);
+            this.addPropertyOrClassStaticBlockStatements(initializerStatements, others, receiver);
+        }
+        else
+            this.addPropertyOrClassStaticBlockStatements(initializerStatements, properties, receiver);
+        const constructorBody = constructor !== undefined && constructor.body instanceof Block ? constructor.body : undefined;
+        if (constructorBody !== undefined) {
+            const nodes = constructorBody.statements.nodes;
+            let offset = 0;
+            while (offset < nodes.length && isPrologueDirective(nodes[offset]))
+                statements.push(nodes[offset++]);
+            const superPath = findSuperStatementIndexPath(nodes.slice(offset), 0);
+            if (superPath.length > 0) {
+                superPath[0] = (superPath[0] | 0) + offset;
+                statements = this.transformConstructorBodyWorker(statements, nodes, offset, superPath, 0, initializerStatements, constructor);
+            }
+            else {
+                offset = this.skipParameterPropertyAssignments(nodes, offset, constructor);
+                appendAll(statements, initializerStatements);
+                appendAll(statements, this.visitArray(nodes.slice(offset)));
+            }
+        }
+        else {
+            if (needsSyntheticConstructor)
+                // `super(...arguments);`
+                statements.push(factory.createExpressionStatement(factory.createCallExpression(factory.createKeywordExpression(107 /* SyntaxKind.SuperKeyword */), [
+                    factory.created(new SpreadElement(factory.createIdentifier('arguments'))),
+                ])));
+            appendAll(statements, initializerStatements);
+        }
+        statements = context.mergeEnvironment(statements, context.endVariableEnvironment());
+        if (statements.length === 0 && constructor === undefined)
+            return undefined;
+        const multiLine = constructorBody !== undefined && constructorBody.statements.nodes.length >= statements.length
+            ? constructorBody.multiLine
+            : statements.length > 0;
+        const members = getMembers(container);
+        const list = constructorBody !== undefined
+            ? new NodeList(constructorBody.statements.pos, constructorBody.statements.end, statements)
+            : new NodeList(members.pos, members.end, statements);
+        const block = factory.created(new Block(list, multiLine));
+        if (constructorBody !== undefined)
+            this.withRange(block, constructorBody);
+        return block;
+    }
+    addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
+        for (let i = 0; i < properties.length; i++) {
+            const property = properties[i];
+            if (isStatic(property) && !this.shouldTransformPrivateElementsOrClassStaticBlocks)
+                continue;
+            const statement = this.transformPropertyOrClassStaticBlock(property, receiver);
+            if (statement !== undefined)
+                statements.push(statement);
+        }
+        return true;
+    }
+    transformStaticBlockInElement(property) {
+        const saved = this.currentClassElement;
+        this.currentClassElement = property;
+        const expression = this.transformClassStaticBlockDeclaration(property);
+        this.currentClassElement = saved;
+        return expression;
+    }
+    transformPropertyOrClassStaticBlock(property, receiver) {
+        const context = this.context;
+        const expression = property instanceof ClassStaticBlockDeclaration
+            ? this.transformStaticBlockInElement(property)
+            : this.transformProperty(property, receiver);
+        if (expression === undefined)
+            return undefined;
+        const statement = this.factory.createExpressionStatement(expression);
+        context.setOriginal(statement, property);
+        context.addEmitFlags(statement, context.getEmitFlags(property) & 384 /* EmitFlags.NoComments */);
+        context.setCommentRange(statement, property.pos, property.end);
+        const original = context.mostOriginal(property);
+        if (original instanceof ParameterDeclaration) {
+            context.setSourceMapRange(statement, original.pos, original.end);
+            context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+        }
+        else
+            context.setSourceMapRange(statement, posPastModifiers(property), property.end);
+        // The statement got a copy of the synthesized comments; don't print them twice.
+        context.setSyntheticLeadingComments(expression, undefined);
+        context.setSyntheticTrailingComments(expression, undefined);
+        // Comments of an auto-accessor go to its getter.
+        if (hasSyntacticModifier(original, 512 /* ModifierFlags.Accessor */))
+            context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+        return statement;
+    }
+    generateInitializedPropertyExpressionsOrClassStaticBlock(properties, receiver) {
+        const expressions = [];
+        for (let i = 0; i < properties.length; i++) {
+            const property = properties[i];
+            const expression = property instanceof ClassStaticBlockDeclaration
+                ? this.transformStaticBlockInElement(property)
+                : this.transformProperty(property, receiver);
+            if (expression === undefined)
+                continue;
+            this.context.setOriginalEx(expression, property, true);
+            this.context.assignCommentAndSourceMapRanges(expression, property);
+            expressions.push(expression);
+        }
+        return expressions;
+    }
+    transformProperty(property, receiver) {
+        const saved = this.currentClassElement;
+        const transformed = this.transformPropertyWorker(property, receiver);
+        if (transformed !== undefined && hasStaticModifier(property)) {
+            const context = this.context;
+            context.addEmitFlags(transformed, 16777216 /* EmitFlags.NoLexicalThis */);
+            if (this.currentClassFacts() !== 0 /* ClassFacts.None */) {
+                context.setOriginal(transformed, property);
+                context.setSourceMapRange(transformed, context.sourceMapPos(property.name), context.sourceMapEnd(property.name));
+            }
+        }
+        this.currentClassElement = saved;
+        return transformed;
+    }
+    transformPropertyWorker(node, receiver) {
+        const factory = this.factory;
+        const context = this.context;
+        const emitAssignment = !this.useDefineForClassFields;
+        const property = this.transformNamedEvaluationIfNeeded(node, '');
+        // The generated name reuses the value cached by the moved computed name expression.
+        let propertyName = property.name;
+        if (hasSyntacticModifier(property, 512 /* ModifierFlags.Accessor */))
+            propertyName = factory.createGeneratedPrivateNameForNode(property.name, '', accessorStorageSuffix);
+        else if (propertyName instanceof ComputedPropertyName && !isSimpleInlineableExpression(propertyName.expression))
+            propertyName = factory.updateComputedPropertyName(propertyName, factory.createGeneratedNameForNode(propertyName, 0, '', ''));
+        if (hasStaticModifier(property))
+            this.currentClassElement = property;
+        if (propertyName instanceof PrivateIdentifier && this.shouldTransformClassElementToWeakMap(property)) {
+            const info = this.accessPrivateIdentifier(propertyName);
+            if (info === undefined)
+                throw new Error('Undeclared private name for property declaration.');
+            if (info.kind !== 0 /* PrivateKind.Field */)
+                return undefined;
+            const initializer = this.visitNode(property.initializer);
+            const value = initializer !== undefined ? initializer : factory.createVoidZero();
+            // `_C_x.set(this, value)`, or `_C_x = { value }` for statics.
+            if (!info.isStatic)
+                return factory.createMethodCall(info.brandCheckIdentifier, 'set', [receiver, value]);
+            return factory.createAssignment(info.variableName, factory.createObjectLiteral([factory.createPropertyAssignment(factory.createIdentifier('value'), value)], false));
+        }
+        if ((propertyName instanceof PrivateIdentifier || hasStaticModifier(property)) &&
+            property.initializer === undefined)
+            return undefined;
+        const original = context.mostOriginal(property);
+        if (hasSyntacticModifier(original, 64 /* ModifierFlags.Abstract */))
+            return undefined;
+        let initializer = this.visitNode(property.initializer);
+        if (isParameterPropertyDeclaration(original, original.parent) && propertyName instanceof Identifier) {
+            // A parameter property's value is its parameter; an initializer here only comes from decorators.
+            const localName = factory.cloneIdentifier(propertyName);
+            if (initializer !== undefined) {
+                // Unwrap `(__runInitializers(this, _instanceExtraInitializers), void 0)`.
+                if (initializer instanceof ParenthesizedExpression) {
+                    const inner = initializer.expression;
+                    if (inner instanceof BinaryExpression &&
+                        inner.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ &&
+                        context.isCallToHelper(inner.left, '__runInitializers') &&
+                        inner.right instanceof VoidExpression &&
+                        inner.right.expression.kind === 8 /* SyntaxKind.NumericLiteral */)
+                        initializer = inner.left;
+                }
+                initializer = factory.inlineExpressions([initializer, localName]);
+            }
+            else
+                initializer = localName;
+            context.addEmitFlags(propertyName, 384 /* EmitFlags.NoComments */ | 12 /* EmitFlags.NoSourceMap */);
+            const originalName = getName(original);
+            context.setSourceMapRange(localName, originalName.pos, originalName.end);
+            context.addEmitFlags(localName, 384 /* EmitFlags.NoComments */);
+        }
+        else if (initializer === undefined)
+            initializer = factory.createVoidZero();
+        if (emitAssignment || propertyName instanceof PrivateIdentifier) {
+            const access = this.createMemberAccessForPropertyName(receiver, propertyName);
+            context.addEmitFlags(access, 128 /* EmitFlags.NoLeadingComments */);
+            return factory.createAssignment(access, initializer);
+        }
+        // useDefineForClassFields: `Object.defineProperty(this, "x", { ... })`
+        let name = propertyName;
+        if (propertyName instanceof ComputedPropertyName)
+            name = propertyName.expression;
+        else if (propertyName instanceof Identifier)
+            name = factory.createStringLiteral(propertyName.text, 0 /* TokenFlags.None */);
+        const descriptor = factory.createObjectLiteral([
+            factory.createPropertyAssignment(factory.createIdentifier('enumerable'), factory.createTrue()),
+            factory.createPropertyAssignment(factory.createIdentifier('configurable'), factory.createTrue()),
+            factory.createPropertyAssignment(factory.createIdentifier('writable'), factory.createTrue()),
+            factory.createPropertyAssignment(factory.createIdentifier('value'), initializer),
+        ], true);
+        return factory.createObjectDefinePropertyCall(receiver, name, descriptor);
+    }
+    createMemberAccessForPropertyName(receiver, name) {
+        const factory = this.factory;
+        if (name instanceof ComputedPropertyName)
+            return this.withRange(factory.createElementAccessExpression(receiver, name.expression), name);
+        const access = name instanceof Identifier || name instanceof PrivateIdentifier
+            ? factory.createPropertyAccessExpression(receiver, name)
+            : factory.createElementAccessExpression(receiver, name);
+        this.context.setCommentRange(access, name.pos, name.end);
+        this.context.setSourceMapRange(access, name.pos, name.end);
+        this.context.addEmitFlags(access, 16 /* EmitFlags.NoNestedSourceMaps */);
+        return access;
+    }
+    /** `_C_instances.add(this)` brands instances for private methods and accessors. */
+    addInstanceMethodStatements(statements, methods, receiver) {
+        if (!this.shouldTransformPrivateElementsOrClassStaticBlocks || methods.length === 0)
+            return false;
+        const weakSetName = this.getPrivateEnvironment().weakSetName;
+        statements.push(this.factory.createExpressionStatement(this.factory.createMethodCall(weakSetName, 'add', [receiver])));
+        return true;
+    }
+    visitInvalidSuperProperty(node) {
+        const factory = this.factory;
+        if (node instanceof PropertyAccessExpression)
+            return factory.updatePropertyAccessExpression(node, factory.createVoidZero(), undefined, node.name, node.flags);
+        const access = node;
+        return factory.updateElementAccessExpression(access, factory.createVoidZero(), undefined, this.visitNode(access.argumentExpression), access.flags);
+    }
+    /**
+     * A visited computed name: an assignment caching its value when it's needed again (`shouldHoist`),
+     * the expression when it has effects, or undefined when it's unused or safe to repeat.
+     */
+    getPropertyNameExpressionIfNeeded(name, shouldHoist) {
+        if (!(name instanceof ComputedPropertyName))
+            return undefined;
+        const cacheAssignment = findComputedPropertyNameCacheAssignment(name);
+        const expression = this.visitInOuterEnvironment(name.expression);
+        const inner = skipOuterExpressions(expression, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */);
+        const inlinable = isSimpleInlineableExpression(inner);
+        const alreadyTransformed = cacheAssignment !== undefined ||
+            (inner instanceof BinaryExpression &&
+                isAssignmentExpression(inner, true) &&
+                inner.left instanceof Identifier &&
+                this.context.hasAutoGenerateInfo(inner.left));
+        if (!alreadyTransformed && !inlinable && shouldHoist) {
+            const generated = this.addHoisted(this.factory.createGeneratedNameForNode(name, 0, '', ''), this.requiresBlockScopedVar());
+            return this.factory.createAssignment(generated, expression);
+        }
+        if (inlinable || inner instanceof Identifier)
+            return undefined;
+        return expression;
+    }
+    getClassData() {
+        const environment = this.lexicalEnvironment;
+        if (environment.data === undefined)
+            environment.data = new ClassData();
+        return environment.data;
+    }
+    getPrivateEnvironment() {
+        const environment = this.lexicalEnvironment;
+        if (environment.privateEnv === undefined)
+            environment.privateEnv = new PrivateEnvironment();
+        return environment.privateEnv;
+    }
+    /** The brand check of a static member: the class, or its classThis. */
+    staticBrandCheck() {
+        const data = this.getClassData();
+        return data.classThis !== undefined ? data.classThis : data.classConstructor;
+    }
+    addPrivateIdentifierPropertyDeclarationToEnvironment(node, name) {
+        const environment = this.getPrivateEnvironment();
+        const isStaticMember = hasStaticModifier(node);
+        const isValid = !this.isReservedPrivateName(name) && this.getPrivateIdentifier(environment, name) === undefined;
+        if (isStaticMember) {
+            const info = new PrivateIdentifierInfo(0 /* PrivateKind.Field */, this.staticBrandCheck(), true, isValid);
+            info.variableName = this.createHoistedVariableForPrivateName(name, '');
+            this.setPrivateIdentifier(environment, name, info);
+            return true;
+        }
+        const weakMapName = this.createHoistedVariableForPrivateName(name, '');
+        this.setPrivateIdentifier(environment, name, new PrivateIdentifierInfo(0 /* PrivateKind.Field */, weakMapName, false, isValid));
+        const factory = this.factory;
+        this.pendingExpressions.push(factory.createAssignment(weakMapName, factory.created(new NewExpression(factory.createIdentifier('WeakMap'), undefined, factory.createNodeList([])))));
+        return true;
+    }
+    addPrivateIdentifierToEnvironment(node) {
+        const environment = this.getPrivateEnvironment();
+        const name = getName(node);
+        const isStaticMember = hasStaticModifier(node);
+        const previous = this.getPrivateIdentifier(environment, name);
+        const isValid = !this.isReservedPrivateName(name) && previous === undefined;
+        if (node instanceof PropertyDeclaration && !isAutoAccessorPropertyDeclaration(node))
+            return this.addPrivateIdentifierPropertyDeclarationToEnvironment(node, name);
+        const brandCheck = isStaticMember ? this.staticBrandCheck() : environment.weakSetName;
+        if (brandCheck === undefined)
+            throw new Error(isStaticMember ? 'classConstructor should be set' : 'weakSetName should be set');
+        if (node instanceof PropertyDeclaration) {
+            const info = new PrivateIdentifierInfo(2 /* PrivateKind.Accessor */, brandCheck, isStaticMember, isValid);
+            info.getterName = this.createHoistedVariableForPrivateName(name, '_get');
+            info.setterName = this.createHoistedVariableForPrivateName(name, '_set');
+            this.setPrivateIdentifier(environment, name, info);
+        }
+        else if (node.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+            const methodName = this.createHoistedVariableForPrivateName(name, '');
+            const info = new PrivateIdentifierInfo(1 /* PrivateKind.Method */, brandCheck, isStaticMember, isValid);
+            info.methodName = methodName;
+            this.setPrivateIdentifier(environment, name, info);
+        }
+        else {
+            const getter = node.kind === 178 /* SyntaxKind.GetAccessor */;
+            const accessorName = this.createHoistedVariableForPrivateName(name, getter ? '_get' : '_set');
+            // A get and set accessor pair shares one entry.
+            if (previous !== undefined &&
+                previous.kind === 2 /* PrivateKind.Accessor */ &&
+                previous.isStatic === isStaticMember &&
+                (getter ? previous.getterName === undefined : previous.setterName === undefined)) {
+                if (getter)
+                    previous.getterName = accessorName;
+                else
+                    previous.setterName = accessorName;
+            }
+            else {
+                const info = new PrivateIdentifierInfo(2 /* PrivateKind.Accessor */, brandCheck, isStaticMember, isValid);
+                if (getter)
+                    info.getterName = accessorName;
+                else
+                    info.setterName = accessorName;
+                this.setPrivateIdentifier(environment, name, info);
+            }
+        }
+        return true;
+    }
+    setPrivateIdentifier(environment, name, info) {
+        if (this.context.hasAutoGenerateInfo(name))
+            environment.generated.set(this.context.getNodeForGeneratedName(name), info);
+        else
+            environment.members.set(privateNameText(name), info);
+        return true;
+    }
+    getPrivateIdentifier(environment, name) {
+        if (this.context.hasAutoGenerateInfo(name))
+            return environment.generated.get(this.context.getNodeForGeneratedName(name));
+        return environment.members.get(privateNameText(name));
+    }
+    /** A hoisted variable such as `_C_x`, prefixed with the class name when it has one. */
+    createHoistedVariableForClass(text, node, suffix) {
+        const className = this.getPrivateEnvironment().className;
+        const prefix = className !== undefined ? '_' + className.text + '_' : '_';
+        const identifier = this.factory.createUniqueNameWithSuffix(prefix + text, 16 /* GeneratedIdentifierFlags.Optimistic */ | 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */, suffix);
+        return this.addHoisted(identifier, this.requiresBlockScopedVar());
+    }
+    createHoistedVariableForPrivateName(name, suffix) {
+        // Generated names, as of auto-accessor storage, are named from their node when printed.
+        if (this.context.hasAutoGenerateInfo(name)) {
+            const className = this.getPrivateEnvironment().className;
+            const prefix = className !== undefined ? '_' + className.text + '_' : '_';
+            const identifier = this.factory.createGeneratedNameForNode(name, 16 /* GeneratedIdentifierFlags.Optimistic */ | 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */, prefix, suffix);
+            return this.addHoisted(identifier, this.requiresBlockScopedVar());
+        }
+        let text = privateNameText(name);
+        if (text.length > 0 && text.charCodeAt(0) === 0x23)
+            text = text.slice(1);
+        return this.createHoistedVariableForClass(text, name, suffix);
+    }
+    /** What a private name declared in this or an enclosing class transforms to. */
+    accessPrivateIdentifier(name) {
+        for (let environment = this.lexicalEnvironment; environment !== undefined; environment = environment.previous) {
+            const privateEnv = environment.privateEnv;
+            if (privateEnv === undefined)
+                continue;
+            const info = this.getPrivateIdentifier(privateEnv, name);
+            if (info !== undefined)
+                return info.kind === 3 /* PrivateKind.Untransformed */ ? undefined : info;
+        }
+        return undefined;
+    }
+    isReservedPrivateName(node) {
+        if (node instanceof PrivateIdentifier && this.context.hasAutoGenerateInfo(node))
+            return false;
+        return privateNameText(node) === '#constructor';
+    }
+    /** `obj.#x` as a destructuring target: `({ set value(_a) { __classPrivateFieldSet(obj, ...); } }).value`. */
+    wrapPrivateIdentifierForDestructuringTarget(node) {
+        const factory = this.factory;
+        const parameter = factory.createGeneratedNameForNode(node, 0, '', '');
+        const info = this.accessPrivateIdentifier(node.name);
+        if (info === undefined)
+            return this.visitEachChild(node);
+        let receiver = node.expression;
+        // `this` and `super` would bind differently in the setter.
+        const kind = node.expression.kind;
+        if (kind === 109 /* SyntaxKind.ThisKeyword */ || kind === 107 /* SyntaxKind.SuperKeyword */ || !isSimpleCopiableExpression(receiver)) {
+            const temp = this.context.addVariableDeclaration(factory.createTempVariable(8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */));
+            this.pendingExpressions.push(factory.createAssignment(temp, this.visitNode(node.expression)));
+            receiver = temp;
+        }
+        return factory.createAssignmentTargetWrapper(parameter, this.createPrivateIdentifierAssignment(info, receiver, parameter, 63 /* SyntaxKind.EqualsToken */));
+    }
+    visitDestructuringAssignmentTarget(node) {
+        if (node instanceof ObjectLiteralExpression || node instanceof ArrayLiteralExpression)
+            return this.visitAssignmentPattern(node);
+        if (node instanceof PropertyAccessExpression && node.name instanceof PrivateIdentifier)
+            return this.wrapPrivateIdentifierForDestructuringTarget(node);
+        const data = this.staticSuperData(node);
+        if (data !== undefined) {
+            if ((data.facts & 1 /* ClassFacts.ClassWasDecorated */) !== 0)
+                return this.visitInvalidSuperProperty(node);
+            if (data.classConstructor !== undefined && data.superClassReference !== undefined) {
+                let name = undefined;
+                if (node instanceof ElementAccessExpression)
+                    name = this.visitNode(node.argumentExpression);
+                else if (node instanceof PropertyAccessExpression && node.name instanceof Identifier)
+                    name = this.factory.createStringLiteralFromNode(node.name);
+                if (name !== undefined) {
+                    const temp = this.factory.createTempVariable(0);
+                    return this.factory.createAssignmentTargetWrapper(temp, this.factory.createReflectSetCall(data.superClassReference, name, temp, data.classConstructor));
+                }
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    visitAssignmentElement(element) {
+        const node = this.transformNamedEvaluationIfNeeded(element, '');
+        if (node instanceof BinaryExpression && isAssignmentExpression(node, true)) {
+            const left = this.visitDestructuringAssignmentTarget(node.left);
+            const right = this.visitNode(node.right);
+            return this.factory.updateBinaryExpression(node, undefined, left, undefined, node.operatorToken, right);
+        }
+        return this.visitDestructuringAssignmentTarget(node);
+    }
+    visitArrayAssignmentElement(node) {
+        if (isArrayBindingOrAssignmentElement(node)) {
+            if (node instanceof SpreadElement) {
+                if (isLeftHandSideExpression(node.expression))
+                    return this.factory.updateSpreadElement(node, this.visitDestructuringAssignmentTarget(node.expression));
+                return this.visitEachChild(node);
+            }
+            if (node.kind !== 233 /* SyntaxKind.OmittedExpression */)
+                return this.visitAssignmentElement(node);
+        }
+        return this.visitEachChild(node);
+    }
+    visitObjectAssignmentElement(node) {
+        const factory = this.factory;
+        if (node instanceof SpreadAssignment) {
+            if (isLeftHandSideExpression(node.expression))
+                return factory.updateSpreadAssignment(node, this.visitDestructuringAssignmentTarget(node.expression));
+            return this.visitEachChild(node);
+        }
+        if (node instanceof ShorthandPropertyAssignment)
+            return this.visitEachChild(this.transformNamedEvaluationIfNeeded(node, ''));
+        if (node instanceof PropertyAssignment) {
+            const name = this.visitNode(node.name);
+            const initializer = node.initializer;
+            if (initializer instanceof BinaryExpression && isAssignmentExpression(initializer, true))
+                return factory.updatePropertyAssignment(node, undefined, name, undefined, undefined, this.visitAssignmentElement(initializer));
+            if (isLeftHandSideExpression(initializer))
+                return factory.updatePropertyAssignment(node, undefined, name, undefined, undefined, this.visitDestructuringAssignmentTarget(initializer));
+            return this.visitEachChild(node);
+        }
+        return this.visitEachChild(node);
+    }
+    /** Private names and static `super` in destructuring targets, as `[{ set value(x) { ... } }.value] = ...`. */
+    visitAssignmentPattern(node) {
+        if (node instanceof ArrayLiteralExpression)
+            return this.factory.updateArrayLiteralExpression(node, this.arrayElementMode.visitNodes(node.elements), node.multiLine);
+        const object = node;
+        return this.factory.updateObjectLiteralExpression(object, this.objectElementMode.visitNodes(object.properties), object.multiLine);
+    }
+    createAccessorPropertyGetRedirector(node, modifiers, name, receiver) {
+        const factory = this.factory;
+        const storage = factory.createGeneratedPrivateNameForNode(node.name, '', accessorStorageSuffix);
+        const body = factory.createBlock([factory.createReturnStatement(factory.createPropertyAccessExpression(receiver, storage))], false);
+        return factory.created(new GetAccessorDeclaration(modifiers, name, undefined, factory.createNodeList([]), undefined, undefined, body));
+    }
+    createAccessorPropertySetRedirector(node, modifiers, name, receiver) {
+        const factory = this.factory;
+        const storage = factory.createGeneratedPrivateNameForNode(node.name, '', accessorStorageSuffix);
+        const assignment = factory.createAssignment(factory.createPropertyAccessExpression(receiver, storage), factory.createIdentifier('value'));
+        const body = factory.createBlock([factory.createExpressionStatement(assignment)], false);
+        const parameters = factory.createNodeList([factory.createParameter(factory.createIdentifier('value'))]);
+        return factory.created(new SetAccessorDeclaration(modifiers, name, undefined, parameters, undefined, undefined, body));
+    }
+    createCallBinding(node) {
+        const factory = this.factory;
+        if (isSuperProperty(node))
+            return new CallBinding(factory.createThisExpression(), node);
+        if (node instanceof PropertyAccessExpression) {
+            if (!shouldBeCapturedInTempVariable(node.expression))
+                return new CallBinding(node.expression, node);
+            const thisArg = this.context.addVariableDeclaration(factory.createTempVariable(0));
+            const target = factory.createPropertyAccessExpression(factory.createParenthesizedExpression(factory.createAssignment(thisArg, node.expression)), node.name);
+            return new CallBinding(thisArg, target);
+        }
+        return new CallBinding(factory.createVoidZero(), node);
+    }
+}
+/** Finds identifiers in member code that resolve to a class, skipping property names. */
+class ConstructorReferenceFinder extends NodeVisitor {
+    resolver;
+    classOriginal;
+    className;
+    constructor(resolver, classOriginal, className) {
+        super();
+        this.resolver = resolver;
+        this.classOriginal = classOriginal;
+        this.className = className;
+    }
+    check(node) {
+        if (node instanceof Identifier && !isSameNode(node, this.className)) {
+            const declaration = this.resolver.getReferencedValueDeclaration(node);
+            if (declaration !== undefined && declaration === this.classOriginal)
+                return true;
+        }
+        if (node instanceof PropertyAccessExpression)
+            return this.check(node.expression);
+        return node.forEachChild(this);
+    }
+    visitNode(node) {
+        return this.check(node);
+    }
+}
+function membersOf(node) {
+    const members = getMembers(node);
+    return members === undefined ? [] : members.nodes;
+}
+function parametersOf(node) {
+    const parameters = getParameters(node);
+    return parameters !== undefined ? parameters : new NodeList(-1, -1, []);
+}
+function appendAll(target, source) {
+    for (let i = 0; i < source.length; i++)
+        target.push(source[i]);
+    return true;
+}
+function classThisOf(context, node) {
+    const classThis = context.getClassThis(node);
+    return classThis instanceof Identifier ? classThis : undefined;
+}
+function privateNameText(node) {
+    if (node instanceof PrivateIdentifier)
+        return node.text;
+    if (node instanceof Identifier)
+        return node.text;
+    return '';
+}
+function isInitializedProperty(node) {
+    return node instanceof PropertyDeclaration && node.initializer !== undefined;
+}
+function isSuperProperty(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.expression.kind === 107 /* SyntaxKind.SuperKeyword */;
+    if (node instanceof ElementAccessExpression)
+        return node.expression.kind === 107 /* SyntaxKind.SuperKeyword */;
+    return false;
+}
+function isStaticPropertyDeclarationOrClassStaticBlock(node) {
+    return (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+        (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(node)));
+}
+function isCompoundAssignment(kind) {
+    return kind >= 64 /* SyntaxKind.FirstCompoundAssignment */ && kind <= 78 /* SyntaxKind.LastCompoundAssignment */;
+}
+function nonAssignmentOperatorForCompoundAssignment(kind) {
+    switch (kind) {
+        case 64 /* SyntaxKind.PlusEqualsToken */:
+            return 39 /* SyntaxKind.PlusToken */;
+        case 65 /* SyntaxKind.MinusEqualsToken */:
+            return 40 /* SyntaxKind.MinusToken */;
+        case 66 /* SyntaxKind.AsteriskEqualsToken */:
+            return 41 /* SyntaxKind.AsteriskToken */;
+        case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+            return 42 /* SyntaxKind.AsteriskAsteriskToken */;
+        case 68 /* SyntaxKind.SlashEqualsToken */:
+            return 43 /* SyntaxKind.SlashToken */;
+        case 69 /* SyntaxKind.PercentEqualsToken */:
+            return 44 /* SyntaxKind.PercentToken */;
+        case 70 /* SyntaxKind.LessThanLessThanEqualsToken */:
+            return 47 /* SyntaxKind.LessThanLessThanToken */;
+        case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+            return 48 /* SyntaxKind.GreaterThanGreaterThanToken */;
+        case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+            return 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */;
+        case 73 /* SyntaxKind.AmpersandEqualsToken */:
+            return 50 /* SyntaxKind.AmpersandToken */;
+        case 74 /* SyntaxKind.BarEqualsToken */:
+            return 51 /* SyntaxKind.BarToken */;
+        case 78 /* SyntaxKind.CaretEqualsToken */:
+            return 52 /* SyntaxKind.CaretToken */;
+        case 75 /* SyntaxKind.BarBarEqualsToken */:
+            return 56 /* SyntaxKind.BarBarToken */;
+        case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+            return 55 /* SyntaxKind.AmpersandAmpersandToken */;
+        case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+            return 60 /* SyntaxKind.QuestionQuestionToken */;
+    }
+    return 0 /* SyntaxKind.Unknown */;
+}
+function isSimpleCopiableExpression(node) {
+    switch (node.kind) {
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 79 /* SyntaxKind.Identifier */:
+            return true;
+    }
+    return node.kind >= 82 /* SyntaxKind.FirstKeyword */ && node.kind <= 166 /* SyntaxKind.LastKeyword */;
+}
+/** A literal or keyword that can be repeated; identifiers may be reassigned in between. */
+function isSimpleInlineableExpression(node) {
+    return node.kind !== 79 /* SyntaxKind.Identifier */ && isSimpleCopiableExpression(node);
+}
+function shouldBeCapturedInTempVariable(node) {
+    switch (skipParentheses(node).kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+            return false;
+    }
+    return true;
+}
+function isArrayBindingOrAssignmentElement(node) {
+    switch (node.kind) {
+        case 209 /* SyntaxKind.BindingElement */:
+        case 233 /* SyntaxKind.OmittedExpression */:
+        case 231 /* SyntaxKind.SpreadElement */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 79 /* SyntaxKind.Identifier */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+            return true;
+    }
+    return isAssignmentExpression(node, true);
+}
+function staticPropertiesAndClassStaticBlocks(node) {
+    const result = [];
+    const members = membersOf(node);
+    for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+            (member.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(member)))
+            result.push(member);
+    }
+    return result;
+}
+function propertiesOf(node, isStaticProperty) {
+    const result = [];
+    const members = membersOf(node);
+    for (let i = 0; i < members.length; i++)
+        if (members[i] instanceof PropertyDeclaration && hasStaticModifier(members[i]) === isStaticProperty)
+            result.push(members[i]);
+    return result;
+}
+function privateInstanceMethodsAndAccessors(node) {
+    const result = [];
+    const members = membersOf(node);
+    for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        if (!isStatic(member) &&
+            (isMethodOrAccessor(member) || isAutoAccessorPropertyDeclaration(member)) &&
+            getName(member).kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            result.push(member);
+    }
+    return result;
+}
+function getClassExtendsHeritageElement(node) {
+    let clauses = undefined;
+    if (node instanceof ClassDeclaration)
+        clauses = node.heritageClauses;
+    else if (node instanceof ClassExpression)
+        clauses = node.heritageClauses;
+    if (clauses === undefined)
+        return undefined;
+    for (let i = 0; i < clauses.nodes.length; i++) {
+        const clause = clauses.nodes[i];
+        if (clause instanceof HeritageClause && clause.token === 95 /* SyntaxKind.ExtendsKeyword */) {
+            const first = clause.types.nodes[0];
+            return first instanceof ExpressionWithTypeArguments ? first : undefined;
+        }
+    }
+    return undefined;
+}
+/** Whether a class or its constructor's parameters have decorators that apply. */
+function classOrConstructorParameterIsDecorated(legacy, node) {
+    if (hasDecorators(node) && (node.kind === 264 /* SyntaxKind.ClassDeclaration */ || !legacy))
+        return true;
+    if (!legacy)
+        return false;
+    const members = membersOf(node);
+    for (let i = 0; i < members.length; i++) {
+        const member = members[i];
+        if (!(member instanceof ConstructorDeclaration) || member.body === undefined)
+            continue;
+        const parameters = member.parameters.nodes;
+        for (let j = 0; j < parameters.length; j++)
+            if (hasDecorators(parameters[j]))
+                return true;
+        return false;
+    }
+    return false;
+}
+/** The `_a = ...` assignment caching a computed name's value, at the end of its comma list. */
+function findComputedPropertyNameCacheAssignment(name) {
+    let node = name.expression;
+    for (;;) {
+        node = skipOuterExpressions(node, 0 /* OuterExpressionKinds.None */);
+        if (node instanceof BinaryExpression && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
+            node = node.right;
+            continue;
+        }
+        if (node instanceof BinaryExpression && isAssignmentExpression(node, true) && node.left instanceof Identifier)
+            return node;
+        return undefined;
+    }
+}
+/** The expressions of a comma list, appended to `out`. */
+function flattenCommaList(node, out) {
+    if (node instanceof ParenthesizedExpression && nodeIsSynthesized(node))
+        return flattenCommaList(node.expression, out);
+    if (node instanceof BinaryExpression && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
+        flattenCommaList(node.left, out);
+        return flattenCommaList(node.right, out);
+    }
+    out.push(node);
+    return true;
+}
+/** The start of a member after its modifiers, or its decorators, for source maps. */
+function posPastModifiers(node) {
+    if (node instanceof PropertyDeclaration)
+        return node.name.pos;
+    if (node instanceof MethodDeclaration)
+        return node.name.pos;
+    if (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+        return node.pos;
+    const modifiers = getModifiers(node);
+    if (modifiers === undefined || modifiers.nodes.length === 0)
+        return node.pos;
+    const last = modifiers.nodes[modifiers.nodes.length - 1];
+    if (last.end >= 0)
+        return last.end;
+    for (let i = modifiers.nodes.length - 1; i >= 0; i--)
+        if (modifiers.nodes[i].kind === 171 /* SyntaxKind.Decorator */)
+            return modifiers.nodes[i].end >= 0 ? modifiers.nodes[i].end : node.pos;
+    return node.pos;
+}
+/** Properties assigned in the constructor with useDefineForClassFields: false. */
+function withInitializerOrPrivateName(properties) {
+    const result = [];
+    for (let i = 0; i < properties.length; i++) {
+        const property = properties[i];
+        if (getInitializer(property) !== undefined ||
+            getName(property).kind === 80 /* SyntaxKind.PrivateIdentifier */ ||
+            hasSyntacticModifier(property, 512 /* ModifierFlags.Accessor */))
+            result.push(property);
+    }
+    return result;
+}
+class ClassesNeedingNames extends AnonymousFunctionFilter {
+    transformer;
+    constructor(transformer) {
+        super();
+        this.transformer = transformer;
+    }
+    accepts(node) {
+        return this.transformer.isAnonymousClassNeedingAssignedName(node);
+    }
+}