tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/legacy-decorators.d.ts

@@ -0,0 +1,56 @@
+import { type Node } from '../ast.js';
+import { type CompilerOptions } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { EmitResolver } from './emit-resolver.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+export declare class LegacyDecorators extends Transformer {
+    private readonly target;
+    private readonly resolver;
+    private readonly facts;
+    /** Aliases of decorated classes that refer to themselves. */
+    private readonly classAliases;
+    /** Decorated classes with aliases whose bodies are being visited. */
+    private enclosingClasses;
+    constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitSourceFile;
+    /** A reference to a decorated class from inside its body becomes a reference to its alias. */
+    private visitIdentifier;
+    private finishClassElement;
+    private visitParameter;
+    /** The visited name of a class element; a decorated computed name is cached in a temporary for `__decorate`. */
+    private visitPropertyNameOfClassElement;
+    private visitPropertyDeclaration;
+    private visitClassDeclaration;
+    private transformClassDeclarationWithoutClassDecorators;
+    /**
+     * A decorated class becomes `let C = class C {}` followed by the decorations; an export of it
+     * moves after them.
+     */
+    private transformClassDeclarationWithClassDecorators;
+    /** Whether a member refers to the class by name, other than as a property name. */
+    private hasInternalStaticReference;
+    isReferenceTo(node: Node, declaration: Node): boolean;
+    /** The declaration the parse-tree identifier behind `node` refers to. */
+    private getReferencedValueDeclaration;
+    private getClassAliasIfNeeded;
+    private getConstructorDecorationStatement;
+    /** `C = __decorate([...], C)`, or `C = C_1 = __decorate([...], C)` with an alias. */
+    private generateConstructorDecorationExpression;
+    /** The members, and the statements decorating them after the class. */
+    private transformDecoratorsOfClassElements;
+    private hasClassElementWithDecoratorContainingPrivateIdentifierInExpression;
+    private someContainsPrivateIdentifierInExpression;
+    /** `__decorate` statements for the static or instance members. */
+    private addClassElementDecorationStatements;
+    /**
+     * `__decorate([...], C.prototype, "name", null)` for a method or accessor, or with `void 0`
+     * for a property, so `__decorate` defines it without reading its descriptor first.
+     */
+    private generateClassElementDecorationExpression;
+    /** The decorator expressions, then `__param` calls, then `__metadata` calls. */
+    private transformAllDecoratorsOfDeclaration;
+    private visitDecoratorExpression;
+    private getExpressionForPropertyName;
+}

package/dist/api/compiler/transformers/legacy-decorators.js

@@ -0,0 +1,564 @@
+// Legacy (`experimentalDecorators`) decorators: decorated classes and members become
+// `__decorate` calls after the class, and parameter decorators `__param` calls.
+//
+//   @dec class C { @m method(@p x) {} }
+// becomes
+//   let C = class C { method(x) {} };
+//   __decorate([m, __param(0, p)], C.prototype, "method", null);
+//   C = __decorate([dec], C);
+//
+// A decorated class that refers to itself inside its body gets an alias (`C_1`) for those
+// references, since a class decorator can replace the class binding.
+import { ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConstructorDeclaration, Decorator, ExportAssignment, ExportDeclaration, ExportSpecifier, GetAccessorDeclaration, Identifier, MethodDeclaration, NamedExports, NodeVisitor, ParameterDeclaration, PrivateIdentifier, PropertyAccessExpression, PropertyDeclaration, SetAccessorDeclaration, SourceFile, getBody, getMembers, getName, getParameters, } from '../ast.js';
+import { canHaveDecorators } from '../ast-utilities.js';
+import { isStatic } from '../binder-utilities.js';
+import { ScriptTarget, getEmitScriptTarget } from '../options.js';
+import { createDecorateHelper, createParamHelper } from '../printer/decorator-helpers.js';
+import { skipPartiallyEmittedExpressions } from '../printer/utilities.js';
+import { childIsDecorated, classOrConstructorParameterIsDecorated, getAllAccessorDeclarations, getDecorators, getFirstConstructorWithBody, isSimpleInlineableExpression, moveRangePastModifiers, nodeOrChildIsDecorated, } from './decorator-utilities.js';
+import { Transformer } from './transformer.js';
+import { hasDecorators, hasSyntacticModifier, isThisParameter } from './utilities.js';
+/** The decorators of a declaration, and of its parameters by index. */
+class AllDecorators {
+    decorators;
+    parameters;
+    constructor(decorators, parameters) {
+        this.decorators = decorators;
+        this.parameters = parameters;
+    }
+}
+class ClassElementDecorations {
+    members;
+    statements;
+    constructor(members, statements) {
+        this.members = members;
+        this.statements = statements;
+    }
+}
+export class LegacyDecorators extends Transformer {
+    target;
+    resolver;
+    facts;
+    /** Aliases of decorated classes that refer to themselves. */
+    classAliases;
+    /** Decorated classes with aliases whose bodies are being visited. */
+    enclosingClasses;
+    constructor(context, options, resolver, facts) {
+        super(context);
+        this.target = getEmitScriptTarget(options);
+        this.resolver = resolver;
+        this.facts = facts;
+        this.classAliases = new Map();
+        this.enclosingClasses = [];
+    }
+    visit(node) {
+        // Identifiers in classes with aliases may need substitution.
+        if (!this.facts.has(node, 262144 /* SubtreeFacts.ContainsDecorators */) && this.enclosingClasses.length === 0)
+            return node;
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+                return node instanceof Identifier ? this.visitIdentifier(node) : node;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                if (node instanceof PropertyAccessExpression) {
+                    // Property names are never substituted.
+                    const expression = this.visitNode(node.expression);
+                    return this.factory.updatePropertyAccessExpression(node, expression, node.questionDotToken, node.name, node.flags);
+                }
+                break;
+            case 171 /* SyntaxKind.Decorator */:
+                // Emitted as part of the class.
+                return undefined;
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                if (node instanceof ClassDeclaration)
+                    return this.visitClassDeclaration(node);
+                break;
+            case 232 /* SyntaxKind.ClassExpression */:
+                if (node instanceof ClassExpression)
+                    // Legacy decorators don't apply to class expressions.
+                    return this.factory.updateClassExpression(node, this.visitModifiers(node.modifiers), node.name, undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
+                break;
+            case 177 /* SyntaxKind.Constructor */:
+                if (node instanceof ConstructorDeclaration)
+                    return this.factory.updateConstructorDeclaration(node, this.visitModifiers(node.modifiers), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                if (node instanceof MethodDeclaration)
+                    return this.finishClassElement(this.factory.updateMethodDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.visitPropertyNameOfClassElement(node), undefined, undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body)), node);
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (node instanceof GetAccessorDeclaration)
+                    return this.finishClassElement(this.factory.updateGetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.visitPropertyNameOfClassElement(node), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body)), node);
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (node instanceof SetAccessorDeclaration)
+                    return this.finishClassElement(this.factory.updateSetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.visitPropertyNameOfClassElement(node), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body)), node);
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (node instanceof PropertyDeclaration)
+                    return this.visitPropertyDeclaration(node);
+                break;
+            case 170 /* SyntaxKind.Parameter */:
+                if (node instanceof ParameterDeclaration)
+                    return this.visitParameter(node);
+                break;
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile)
+                    return this.visitSourceFile(node);
+                break;
+        }
+        return this.visitEachChild(node);
+    }
+    visitSourceFile(node) {
+        this.classAliases.clear();
+        this.enclosingClasses = [];
+        const result = this.visitEachChild(node);
+        const helpers = this.context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            this.context.addEmitHelper(result, helpers[i]);
+        this.classAliases.clear();
+        return result;
+    }
+    /** A reference to a decorated class from inside its body becomes a reference to its alias. */
+    visitIdentifier(node) {
+        if (this.enclosingClasses.length === 0)
+            return node;
+        const declaration = this.getReferencedValueDeclaration(node);
+        if (declaration === undefined)
+            return node;
+        for (let i = 0; i < this.enclosingClasses.length; i++) {
+            const enclosing = this.enclosingClasses[i];
+            const alias = this.classAliases.get(enclosing);
+            if (alias !== undefined && declaration === this.context.mostOriginal(enclosing))
+                return alias;
+        }
+        return node;
+    }
+    finishClassElement(updated, original) {
+        if (updated !== original) {
+            // Source maps skip the decorators and modifiers; comments keep the original range.
+            this.context.setCommentRange(updated, original.pos, original.end);
+            const range = moveRangePastModifiers(original);
+            this.context.setSourceMapRange(updated, range.pos, range.end);
+        }
+        return updated;
+    }
+    visitParameter(node) {
+        const updated = this.factory.updateParameterDeclaration(node, elideModifiers(this, node.modifiers), node.dotDotDotToken, this.visitNode(node.name), undefined, undefined, this.visitNode(node.initializer));
+        if (updated !== node) {
+            this.context.setCommentRange(updated, node.pos, node.end);
+            const range = moveRangePastModifiers(node);
+            updated.pos = range.pos | 0;
+            updated.end = range.end | 0;
+            this.context.setSourceMapRange(updated, range.pos, range.end);
+            if (updated instanceof ParameterDeclaration)
+                this.context.setEmitFlags(updated.name, 8 /* EmitFlags.NoTrailingSourceMap */);
+        }
+        return updated;
+    }
+    /** The visited name of a class element; a decorated computed name is cached in a temporary for `__decorate`. */
+    visitPropertyNameOfClassElement(member) {
+        const name = getName(member);
+        if (name instanceof ComputedPropertyName && hasDecorators(member)) {
+            const expression = this.visitNode(name.expression);
+            if (!isSimpleInlineableExpression(skipPartiallyEmittedExpressions(expression))) {
+                const generated = this.factory.createGeneratedNameForNode(name, 0, '', '');
+                this.context.addVariableDeclaration(generated);
+                return this.factory.updateComputedPropertyName(name, this.factory.createAssignment(generated, expression));
+            }
+        }
+        return this.visitNode(name);
+    }
+    visitPropertyDeclaration(node) {
+        if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
+            return undefined;
+        if (hasSyntacticModifier(node, 128 /* ModifierFlags.Ambient */ | 64 /* ModifierFlags.Abstract */))
+            return undefined;
+        return this.finishClassElement(this.factory.updatePropertyDeclaration(node, this.visitModifiers(node.modifiers), this.visitPropertyNameOfClassElement(node), undefined, undefined, this.visitNode(node.initializer)), node);
+    }
+    // Classes
+    visitClassDeclaration(node) {
+        const decorated = classOrConstructorParameterIsDecorated(true, node);
+        if (!decorated && !childIsDecorated(true, node, undefined))
+            return this.visitEachChild(node);
+        if (decorated)
+            return this.transformClassDeclarationWithClassDecorators(node, node.name);
+        return this.transformClassDeclarationWithoutClassDecorators(node, node.name);
+    }
+    transformClassDeclarationWithoutClassDecorators(node, name) {
+        const modifiers = this.visitModifiers(node.modifiers);
+        const heritageClauses = this.visitNodes(node.heritageClauses);
+        const visitedMembers = this.visitNodes(node.members);
+        const decorations = this.transformDecoratorsOfClassElements(node, visitedMembers);
+        const members = decorations.members;
+        const decorationStatements = decorations.statements;
+        if (name === undefined && decorationStatements.length > 0)
+            name = this.factory.createGeneratedNameForNode(node, 0, '', '');
+        const updated = this.factory.updateClassDeclaration(node, modifiers, name, undefined, heritageClauses, members);
+        if (decorationStatements.length === 0)
+            return updated;
+        return this.factory.createSyntaxList([updated].concat(decorationStatements));
+    }
+    /**
+     * A decorated class becomes `let C = class C {}` followed by the decorations; an export of it
+     * moves after them.
+     */
+    transformClassDeclarationWithClassDecorators(node, name) {
+        const factory = this.factory;
+        const context = this.context;
+        const isExport = hasSyntacticModifier(node, 32 /* ModifierFlags.Export */);
+        const isDefault = hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */);
+        let modifiers = undefined;
+        if (node.modifiers !== undefined && node.modifiers.nodes.length > 0) {
+            const kept = [];
+            for (let i = 0; i < node.modifiers.nodes.length; i++) {
+                const modifier = node.modifiers.nodes[i];
+                if (!(modifier instanceof Decorator) &&
+                    modifier.kind !== 94 /* SyntaxKind.ExportKeyword */ &&
+                    modifier.kind !== 89 /* SyntaxKind.DefaultKeyword */)
+                    kept.push(modifier);
+            }
+            if (kept.length !== node.modifiers.nodes.length) {
+                modifiers = factory.createModifierList(kept);
+                modifiers.pos = node.modifiers.pos;
+                modifiers.end = node.modifiers.end;
+            }
+            else
+                modifiers = node.modifiers;
+        }
+        const location = moveRangePastModifiers(node);
+        const classAlias = this.getClassAliasIfNeeded(node);
+        if (classAlias !== undefined)
+            this.enclosingClasses.push(node);
+        // Always the local name: there are no ES5 IIFEs to name differently.
+        const declarationName = factory.getLocalName(node, 2 /* NameOptions.AllowSourceMaps */);
+        const heritageClauses = this.visitNodes(node.heritageClauses);
+        const visitedMembers = this.visitNodes(node.members);
+        const decorations = this.transformDecoratorsOfClassElements(node, visitedMembers);
+        let members = decorations.members;
+        const decorationStatements = decorations.statements;
+        // From ES2022, the alias must be assigned before static initializers run.
+        const assignClassAliasInStaticBlock = this.target >= ScriptTarget.ES2022 &&
+            classAlias !== undefined &&
+            members.nodes.length > 0 &&
+            members.nodes.some(isClassStaticBlockDeclarationOrStaticProperty);
+        if (assignClassAliasInStaticBlock) {
+            const block = factory.created(new ClassStaticBlockDeclaration(undefined, factory.createBlock([
+                factory.createExpressionStatement(factory.createAssignment(classAlias, factory.createKeywordExpression(109 /* SyntaxKind.ThisKeyword */))),
+            ], false)));
+            const list = factory.createNodeList([block].concat(members.nodes));
+            list.pos = members.pos;
+            list.end = members.end;
+            members = list;
+        }
+        const expressionName = name !== undefined && context.hasAutoGenerateInfo(name) ? undefined : name;
+        const classExpression = factory.created(new ClassExpression(modifiers, expressionName, undefined, heritageClauses, members));
+        context.setOriginal(classExpression, node);
+        classExpression.pos = location.pos | 0;
+        classExpression.end = location.end | 0;
+        const initializer = classAlias !== undefined && !assignClassAliasInStaticBlock
+            ? factory.createAssignment(classAlias, classExpression)
+            : classExpression;
+        const declaration = factory.createVariableDeclaration(declarationName, undefined, undefined, initializer);
+        context.setOriginal(declaration, node);
+        const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([declaration]), 1 /* NodeFlags.Let */));
+        context.setOriginal(statement, node);
+        statement.pos = location.pos | 0;
+        statement.end = location.end | 0;
+        context.setCommentRange(statement, node.pos, node.end);
+        const statements = [statement];
+        for (let i = 0; i < decorationStatements.length; i++)
+            statements.push(decorationStatements[i]);
+        const constructorDecoration = this.getConstructorDecorationStatement(node);
+        if (constructorDecoration !== undefined)
+            statements.push(constructorDecoration);
+        if (isExport) {
+            if (isDefault)
+                statements.push(factory.created(new ExportAssignment(undefined, false, undefined, declarationName)));
+            else {
+                const specifier = factory.created(new ExportSpecifier(false, undefined, factory.getDeclarationName(node, 0 /* NameOptions.None */)));
+                statements.push(factory.created(new ExportDeclaration(undefined, false, factory.created(new NamedExports(factory.createNodeList([specifier]))), undefined, undefined)));
+            }
+        }
+        if (classAlias !== undefined)
+            this.enclosingClasses.pop();
+        return statements.length === 1 ? statements[0] : factory.createSyntaxList(statements);
+    }
+    /** Whether a member refers to the class by name, other than as a property name. */
+    hasInternalStaticReference(node) {
+        const classNode = this.context.mostOriginal(node);
+        const members = node.members.nodes;
+        const finder = new SelfReferenceFinder(this, classNode);
+        for (let i = 0; i < members.length; i++)
+            if (members[i].forEachChild(finder))
+                return true;
+        return false;
+    }
+    isReferenceTo(node, declaration) {
+        return node instanceof Identifier && this.getReferencedValueDeclaration(node) === declaration;
+    }
+    /** The declaration the parse-tree identifier behind `node` refers to. */
+    getReferencedValueDeclaration(node) {
+        const original = this.context.mostOriginal(node);
+        if (original instanceof Identifier && (original.flags & 16 /* NodeFlags.Synthesized */) === 0) {
+            return this.resolver.getReferencedValueDeclaration(original);
+        }
+        return undefined;
+    }
+    getClassAliasIfNeeded(node) {
+        if (!this.hasInternalStaticReference(node))
+            return undefined;
+        const name = node.name;
+        const text = name !== undefined && !this.context.hasAutoGenerateInfo(name) ? name.text : 'default';
+        const alias = this.factory.createUniqueName(text, 0);
+        this.context.addVariableDeclaration(alias);
+        this.classAliases.set(node, alias);
+        return alias;
+    }
+    getConstructorDecorationStatement(node) {
+        const expression = this.generateConstructorDecorationExpression(node);
+        if (expression === undefined)
+            return undefined;
+        const statement = this.factory.createExpressionStatement(expression);
+        this.context.setOriginal(statement, node);
+        return statement;
+    }
+    /** `C = __decorate([...], C)`, or `C = C_1 = __decorate([...], C)` with an alias. */
+    generateConstructorDecorationExpression(node) {
+        const all = getAllDecoratorsOfClass(node);
+        // Class decorators are evaluated outside the class body, where its name isn't aliased.
+        const enclosing = this.enclosingClasses;
+        const aliased = enclosing.length > 0 && enclosing[enclosing.length - 1] === node;
+        if (aliased)
+            enclosing.pop();
+        const decoratorExpressions = this.transformAllDecoratorsOfDeclaration(all);
+        if (aliased)
+            enclosing.push(node);
+        if (decoratorExpressions.length === 0)
+            return undefined;
+        const factory = this.factory;
+        const classAlias = this.classAliases.get(node);
+        const localName = factory.getDeclarationName(node, 2 /* NameOptions.AllowSourceMaps */);
+        const decorate = createDecorateHelper(factory, decoratorExpressions, localName, undefined, undefined);
+        const value = classAlias !== undefined ? factory.createAssignment(classAlias, decorate) : decorate;
+        const expression = factory.createAssignment(localName, value);
+        this.context.setEmitFlags(expression, 384 /* EmitFlags.NoComments */);
+        const range = moveRangePastModifiers(node);
+        this.context.setSourceMapRange(expression, range.pos, range.end);
+        return expression;
+    }
+    // Members
+    /** The members, and the statements decorating them after the class. */
+    transformDecoratorsOfClassElements(node, members) {
+        const statements = [];
+        this.addClassElementDecorationStatements(node, false, statements);
+        this.addClassElementDecorationStatements(node, true, statements);
+        // Decorators using private names must run in the class's private name scope.
+        if (!this.hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node))
+            return new ClassElementDecorations(members, statements);
+        const block = this.factory.created(new ClassStaticBlockDeclaration(undefined, this.factory.createBlock(statements, true)));
+        const extra = [block];
+        return new ClassElementDecorations(this.factory.createNodeList(members.nodes.concat(extra)), []);
+    }
+    hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node) {
+        const members = node.members.nodes;
+        for (let i = 0; i < members.length; i++) {
+            const member = members[i];
+            if (!canHaveDecorators(member))
+                continue;
+            const all = getAllDecoratorsOfClassElement(member, node);
+            if (all === undefined)
+                continue;
+            if (this.someContainsPrivateIdentifierInExpression(all.decorators))
+                return true;
+            for (let j = 0; j < all.parameters.length; j++) {
+                const parameter = all.parameters[j];
+                if (parameter !== undefined && this.someContainsPrivateIdentifierInExpression(parameter))
+                    return true;
+            }
+        }
+        return false;
+    }
+    someContainsPrivateIdentifierInExpression(decorators) {
+        for (let i = 0; i < decorators.length; i++)
+            if (this.facts.has(decorators[i], 1048576 /* SubtreeFacts.ContainsPrivateIdentifierInExpression */))
+                return true;
+        return false;
+    }
+    /** `__decorate` statements for the static or instance members. */
+    addClassElementDecorationStatements(node, isStaticMember, statements) {
+        const members = node.members.nodes;
+        for (let i = 0; i < members.length; i++) {
+            const member = members[i];
+            if (isStatic(member) !== isStaticMember || !nodeOrChildIsDecorated(true, member, node, undefined))
+                continue;
+            const expression = this.generateClassElementDecorationExpression(node, member);
+            if (expression !== undefined)
+                statements.push(this.factory.createExpressionStatement(expression));
+        }
+        return true;
+    }
+    /**
+     * `__decorate([...], C.prototype, "name", null)` for a method or accessor, or with `void 0`
+     * for a property, so `__decorate` defines it without reading its descriptor first.
+     */
+    generateClassElementDecorationExpression(node, member) {
+        const all = getAllDecoratorsOfClassElement(member, node);
+        const decoratorExpressions = this.transformAllDecoratorsOfDeclaration(all);
+        if (decoratorExpressions.length === 0)
+            return undefined;
+        const factory = this.factory;
+        const prefix = isStatic(member)
+            ? factory.getDeclarationName(node, 0 /* NameOptions.None */)
+            : factory.createPropertyAccessExpression(factory.getDeclarationName(node, 0 /* NameOptions.None */), factory.createIdentifier('prototype'));
+        const memberName = this.getExpressionForPropertyName(member, (member.flags & 8388608 /* NodeFlags.Ambient */) === 0);
+        const descriptor = member instanceof PropertyDeclaration && !hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */)
+            ? factory.createVoidZero()
+            : factory.createKeywordExpression(105 /* SyntaxKind.NullKeyword */);
+        const helper = createDecorateHelper(factory, decoratorExpressions, prefix, memberName, descriptor);
+        this.context.setEmitFlags(helper, 384 /* EmitFlags.NoComments */);
+        const range = moveRangePastModifiers(member);
+        this.context.setSourceMapRange(helper, range.pos, range.end);
+        return helper;
+    }
+    /** The decorator expressions, then `__param` calls, then `__metadata` calls. */
+    transformAllDecoratorsOfDeclaration(all) {
+        const expressions = [];
+        if (all === undefined)
+            return expressions;
+        const metadata = [];
+        for (let i = 0; i < all.decorators.length; i++) {
+            const decorator = all.decorators[i];
+            if (decorator instanceof Decorator && this.factory.isCallToHelper(decorator.expression, '__metadata'))
+                metadata.push(decorator);
+            else
+                expressions.push(this.visitDecoratorExpression(decorator));
+        }
+        for (let i = 0; i < all.parameters.length; i++) {
+            const decorators = all.parameters[i];
+            if (decorators === undefined)
+                continue;
+            for (let j = 0; j < decorators.length; j++) {
+                const decorator = decorators[j];
+                if (!(decorator instanceof Decorator))
+                    continue;
+                const expression = decorator.expression;
+                const helper = createParamHelper(this.factory, this.visitNode(expression), i, expression.pos, expression.end);
+                this.context.setEmitFlags(helper, 384 /* EmitFlags.NoComments */);
+                expressions.push(helper);
+            }
+        }
+        for (let i = 0; i < metadata.length; i++)
+            expressions.push(this.visitDecoratorExpression(metadata[i]));
+        return expressions;
+    }
+    visitDecoratorExpression(decorator) {
+        return decorator instanceof Decorator ? this.visitNode(decorator.expression) : decorator;
+    }
+    getExpressionForPropertyName(member, generateNameForComputedPropertyName) {
+        const name = getName(member);
+        const factory = this.factory;
+        if (name instanceof PrivateIdentifier)
+            return factory.createIdentifier('');
+        if (name instanceof ComputedPropertyName) {
+            if (generateNameForComputedPropertyName && !isSimpleInlineableExpression(name.expression))
+                return factory.createGeneratedNameForNode(name, 0, '', '');
+            return name.expression;
+        }
+        if (name instanceof Identifier)
+            return factory.createStringLiteral(name.text, 0 /* TokenFlags.None */);
+        return factory.cloneNode(name, name.deepClone());
+    }
+}
+/** Finds a reference to a class among the children of its members; property names don't count. */
+class SelfReferenceFinder extends NodeVisitor {
+    transformer;
+    declaration;
+    constructor(transformer, declaration) {
+        super();
+        this.transformer = transformer;
+        this.declaration = declaration;
+    }
+    visitNode(node) {
+        if (this.transformer.isReferenceTo(node, this.declaration))
+            return true;
+        if (node instanceof PropertyAccessExpression)
+            return this.visitNode(node.expression);
+        return node.forEachChild(this);
+    }
+}
+function elideModifiers(transformer, modifiers) {
+    if (modifiers === undefined || modifiers.nodes.length === 0)
+        return modifiers;
+    const replacement = transformer.factory.createModifierList([]);
+    replacement.pos = modifiers.pos;
+    replacement.end = modifiers.end;
+    return replacement;
+}
+function isClassStaticBlockDeclarationOrStaticProperty(node) {
+    return (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+        (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasSyntacticModifier(node, 256 /* ModifierFlags.Static */)));
+}
+function getAllDecoratorsOfClass(node) {
+    const decorators = getDecorators(node);
+    const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node));
+    if (decorators.length === 0 && parameters.length === 0)
+        return undefined;
+    return new AllDecorators(decorators, parameters);
+}
+function getAllDecoratorsOfClassElement(member, parent) {
+    switch (member.kind) {
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            return getAllDecoratorsOfAccessors(member, parent);
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            return getAllDecoratorsOfMethod(member);
+        case 173 /* SyntaxKind.PropertyDeclaration */: {
+            const decorators = getDecorators(member);
+            return decorators.length === 0 ? undefined : new AllDecorators(decorators, []);
+        }
+    }
+    return undefined;
+}
+/** Decorators of an accessor pair apply once, on the first accessor that has them. */
+function getAllDecoratorsOfAccessors(accessor, parent) {
+    if (getBody(accessor) === undefined)
+        return undefined;
+    const accessors = getAllAccessorDeclarations(getMembers(parent).nodes, accessor);
+    const first = accessors.firstWithDecorators();
+    if (first === undefined || accessor !== first)
+        return undefined;
+    const decorators = getDecorators(first);
+    const parameters = accessors.setAccessor !== undefined ? getDecoratorsOfParameters(accessors.setAccessor) : noParameters;
+    if (decorators.length === 0 && parameters.length === 0)
+        return undefined;
+    return new AllDecorators(decorators, parameters);
+}
+function getAllDecoratorsOfMethod(method) {
+    if (!(method instanceof MethodDeclaration) || method.body === undefined)
+        return undefined;
+    const decorators = getDecorators(method);
+    const parameters = getDecoratorsOfParameters(method);
+    if (decorators.length === 0 && parameters.length === 0)
+        return undefined;
+    return new AllDecorators(decorators, parameters);
+}
+const noParameters = [];
+/** The decorators of each parameter after `this`, or an empty array if none are decorated. */
+function getDecoratorsOfParameters(node) {
+    const result = [];
+    if (node === undefined)
+        return result;
+    const parameters = getParameters(node).nodes;
+    const offset = parameters.length > 0 && isThisParameter(parameters[0]) ? 1 : 0;
+    const count = parameters.length - offset;
+    for (let i = 0; i < count; i++) {
+        const parameter = parameters[i + offset];
+        if (result.length > 0 || hasDecorators(parameter)) {
+            if (result.length === 0)
+                for (let j = 0; j < count; j++)
+                    result.push(undefined);
+            result[i] = getDecorators(parameter);
+        }
+    }
+    return result;
+}

package/dist/api/compiler/transformers/logical-assignment.d.ts

@@ -0,0 +1,14 @@
+import { type Node } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+export declare class LogicalAssignmentTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitLogicalAssignment;
+    /** `expression`, or a temporary to hold it when it can't be evaluated twice. */
+    private copiableObject;
+    /** `expression`, or its assignment to the temporary `copy` holding it. */
+    private assignedObject;
+}