tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/for-await.js

@@ -0,0 +1,469 @@
+// ES2018 async iteration: async generators become generators run by `__asyncGenerator`, and
+// `for await` loops iterate `__asyncValues(x)` by hand, closing the iterator on early exit.
+import { ArrowFunction, Block, CatchClause, ConstructorDeclaration, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, IfStatement, LabeledStatement, MethodDeclaration, ReturnStatement, SetAccessorDeclaration, SourceFile, ThrowStatement, TryStatement, VariableDeclarationList, YieldExpression, AwaitExpression, getBody, getName, getParameters, } from '../ast.js';
+import { advancedAsyncSuperHelper, asyncSuperHelper, createAsyncDelegatorHelper, createAsyncGeneratorHelper, createAsyncValuesHelper, createAwaitHelper, } from '../printer/async-helpers.js';
+import { SuperAccess, getFunctionFlags, isSimpleParameterList } from './async-utilities.js';
+import { Transformer } from './transformer.js';
+import { VisitorBase } from './visitor-base.js';
+/** Visits subtrees without async iteration, tracking `super` accesses only. */
+class FallbackVisitor extends VisitorBase {
+    owner;
+    constructor(owner) {
+        super(owner.context);
+        this.owner = owner;
+    }
+    visit(node) {
+        return this.owner.fallback(node);
+    }
+}
+export class AsyncIteration extends Transformer {
+    facts;
+    superAccess;
+    fallbackVisitor;
+    enclosingFunctionFlags;
+    hierarchyFacts;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+        this.superAccess = new SuperAccess(context);
+        this.fallbackVisitor = new FallbackVisitor(this);
+        this.enclosingFunctionFlags = 0 /* FunctionFlags.Normal */;
+        this.hierarchyFacts = 0 /* HierarchyFacts.None */;
+    }
+    fallback(node) {
+        if (this.superAccess.capturedSuperProperties === undefined)
+            return node;
+        switch (node.kind) {
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.Constructor */:
+                return node;
+        }
+        this.superAccess.track(node);
+        return this.fallbackVisitor.visitEachChild(node);
+    }
+    inAsyncGenerator() {
+        return (this.enclosingFunctionFlags & 3 /* FunctionFlags.AsyncGenerator */) === 3 /* FunctionFlags.AsyncGenerator */;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 256 /* SubtreeFacts.ContainsForAwaitOrAsyncGenerator */))
+            return this.fallback(node);
+        this.superAccess.track(node);
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile)
+                    return this.visitSourceFile(node);
+                break;
+            case 224 /* SyntaxKind.AwaitExpression */:
+                if (node instanceof AwaitExpression)
+                    return this.visitAwaitExpression(node);
+                break;
+            case 230 /* SyntaxKind.YieldExpression */:
+                if (node instanceof YieldExpression)
+                    return this.visitYieldExpression(node);
+                break;
+            case 254 /* SyntaxKind.ReturnStatement */:
+                if (node instanceof ReturnStatement)
+                    return this.visitReturnStatement(node);
+                break;
+            case 257 /* SyntaxKind.LabeledStatement */:
+                if (node instanceof LabeledStatement)
+                    return this.visitLabeledStatement(node);
+                break;
+            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.WhileStatement */:
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 249 /* SyntaxKind.ForStatement */:
+                return this.visitWithFacts(node, 0 /* HierarchyFacts.None */, 2 /* HierarchyFacts.IterationContainer */);
+            case 251 /* SyntaxKind.ForOfStatement */:
+                if (node instanceof ForInOrOfStatement)
+                    return this.visitForOfStatement(node, undefined);
+                break;
+            case 220 /* SyntaxKind.ArrowFunction */:
+                return this.visitWithFacts(node, 2 /* HierarchyFacts.IterationContainer */, 0 /* HierarchyFacts.None */);
+            case 177 /* SyntaxKind.Constructor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+                return this.visitWithFacts(node, 2 /* HierarchyFacts.IterationContainer */, 1 /* HierarchyFacts.HasLexicalThis */);
+        }
+        return this.visitEachChild(node);
+    }
+    visitWithFacts(node, exclude, include) {
+        const ancestorFacts = this.hierarchyFacts;
+        this.hierarchyFacts = (ancestorFacts & ~exclude) | include;
+        const result = this.visitScope(node);
+        this.hierarchyFacts = ancestorFacts;
+        return result;
+    }
+    visitScope(node) {
+        if (node instanceof ConstructorDeclaration)
+            return this.visitConstructor(node);
+        if (node instanceof MethodDeclaration)
+            return this.visitMethodDeclaration(node);
+        if (node instanceof GetAccessorDeclaration)
+            return this.visitGetAccessor(node);
+        if (node instanceof SetAccessorDeclaration)
+            return this.visitSetAccessor(node);
+        if (node instanceof FunctionDeclaration)
+            return this.visitFunctionDeclaration(node);
+        if (node instanceof FunctionExpression)
+            return this.visitFunctionExpression(node);
+        if (node instanceof ArrowFunction)
+            return this.visitArrowFunction(node);
+        return this.visitEachChild(node);
+    }
+    visitSourceFile(node) {
+        const ancestorFacts = this.hierarchyFacts;
+        this.hierarchyFacts = ancestorFacts & ~2 /* HierarchyFacts.IterationContainer */;
+        const visited = this.visitEachChild(node);
+        const helpers = this.context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            this.context.addEmitHelper(visited, helpers[i]);
+        this.hierarchyFacts = ancestorFacts;
+        return visited;
+    }
+    /** `await x` in an async generator as `yield __await(x)`. */
+    visitAwaitExpression(node) {
+        if (!this.inAsyncGenerator())
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        const result = factory.created(new YieldExpression(undefined, createAwaitHelper(factory, this.visitNode(node.expression))));
+        result.pos = node.pos;
+        result.end = node.end;
+        this.context.setOriginal(result, node);
+        return result;
+    }
+    /** `yield x` as `yield yield __await(x)`; `yield* x` as `yield __await(yield* __asyncDelegator(__asyncValues(x)))`. */
+    visitYieldExpression(node) {
+        if (!this.inAsyncGenerator())
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        let inner;
+        if (node.asteriskToken !== undefined) {
+            const expression = this.visitNode(node.expression);
+            const values = createAsyncValuesHelper(factory, expression);
+            values.pos = expression.pos;
+            values.end = expression.end;
+            const delegator = createAsyncDelegatorHelper(factory, values);
+            delegator.pos = expression.pos;
+            delegator.end = expression.end;
+            inner = createAwaitHelper(factory, factory.updateYieldExpression(node, node.asteriskToken, delegator));
+        }
+        else
+            inner = this.createDownlevelAwait(node.expression !== undefined ? this.visitNode(node.expression) : factory.createVoidZero());
+        const result = factory.created(new YieldExpression(undefined, inner));
+        result.pos = node.pos;
+        result.end = node.end;
+        this.context.setOriginal(result, node);
+        return result;
+    }
+    visitReturnStatement(node) {
+        if (!this.inAsyncGenerator())
+            return this.visitEachChild(node);
+        const expression = node.expression !== undefined ? this.visitNode(node.expression) : this.factory.createVoidZero();
+        return this.factory.updateReturnStatement(node, this.createDownlevelAwait(expression));
+    }
+    visitLabeledStatement(node) {
+        if ((this.enclosingFunctionFlags & 2 /* FunctionFlags.Async */) === 0)
+            return this.visitEachChild(node);
+        let innermost = node;
+        while (innermost.statement instanceof LabeledStatement)
+            innermost = innermost.statement;
+        const statement = innermost.statement;
+        if (statement instanceof ForInOrOfStatement && statement.awaitModifier !== undefined)
+            return this.visitForOfStatement(statement, node);
+        return this.restoreEnclosingLabel(this.visitNode(statement), node);
+    }
+    restoreEnclosingLabel(node, outermost) {
+        if (outermost === undefined)
+            return node;
+        const inner = outermost.statement instanceof LabeledStatement ? this.restoreEnclosingLabel(node, outermost.statement) : node;
+        return this.factory.updateLabeledStatement(outermost, outermost.label, inner);
+    }
+    visitForOfStatement(node, outermost) {
+        const ancestorFacts = this.hierarchyFacts;
+        this.hierarchyFacts = ancestorFacts | 2 /* HierarchyFacts.IterationContainer */;
+        const result = node.awaitModifier !== undefined
+            ? this.transformForAwaitOfStatement(node, outermost, ancestorFacts)
+            : this.restoreEnclosingLabel(this.visitEachChild(node), outermost);
+        this.hierarchyFacts = ancestorFacts;
+        return result;
+    }
+    createDownlevelAwait(expression) {
+        const factory = this.factory;
+        if ((this.enclosingFunctionFlags & 1 /* FunctionFlags.Generator */) !== 0)
+            return factory.created(new YieldExpression(undefined, createAwaitHelper(factory, expression)));
+        return factory.created(new AwaitExpression(expression));
+    }
+    /** The loop body: assigns the iterated value, clears `nonUserCode`, binds the loop variable. */
+    convertForOfStatementHead(node, boundValue, nonUserCode) {
+        const factory = this.factory;
+        const context = this.context;
+        const value = factory.createTempVariable(0 /* GeneratedIdentifierFlags.None */);
+        context.addVariableDeclaration(value);
+        const valueStatement = factory.createExpressionStatement(factory.createAssignment(value, boundValue));
+        context.setSourceMapRange(valueStatement, node.expression.pos, node.expression.end);
+        const exitNonUserCode = factory.createExpressionStatement(factory.createAssignment(nonUserCode, factory.createKeywordExpression(96 /* SyntaxKind.FalseKeyword */)));
+        context.setSourceMapRange(exitNonUserCode, node.expression.pos, node.expression.end);
+        const statements = [valueStatement, exitNonUserCode];
+        statements.push(this.visitNode(this.createForOfBindingStatement(node.initializer, value)));
+        const statement = this.visitEmbeddedStatement(node.statement);
+        // Without a block body, tsgo leaves both ranges empty at the start of the file.
+        let pos = 0;
+        let end = 0;
+        let listPos = 0;
+        let listEnd = 0;
+        if (statement instanceof Block) {
+            const nodes = statement.statements.nodes;
+            for (let i = 0; i < nodes.length; i++)
+                statements.push(nodes[i]);
+            pos = statement.pos;
+            end = statement.end;
+            listPos = statement.statements.pos;
+            listEnd = statement.statements.end;
+        }
+        else
+            statements.push(statement);
+        const block = factory.createBlock(statements, true);
+        block.statements.pos = listPos;
+        block.statements.end = listEnd;
+        block.pos = pos;
+        block.end = end;
+        return block;
+    }
+    createForOfBindingStatement(node, boundValue) {
+        const factory = this.factory;
+        if (node instanceof VariableDeclarationList) {
+            const first = node.declarations.nodes[0];
+            const declaration = factory.createVariableDeclaration(getName(first), undefined, undefined, boundValue);
+            factory.cloneNode(first, declaration);
+            const statement = factory.createVariableStatement(undefined, factory.updateVariableDeclarationList(node, factory.createNodeList([declaration]), node.flags));
+            statement.pos = node.pos;
+            statement.end = node.end;
+            return statement;
+        }
+        const assignment = factory.createAssignment(node, boundValue);
+        assignment.pos = node.pos;
+        assignment.end = node.end;
+        const statement = factory.createExpressionStatement(assignment);
+        statement.pos = node.pos;
+        statement.end = node.end;
+        return statement;
+    }
+    transformForAwaitOfStatement(node, outermost, ancestorFacts) {
+        const factory = this.factory;
+        const context = this.context;
+        const expression = this.visitNode(node.expression);
+        const iterator = expression instanceof Identifier
+            ? factory.createGeneratedNameForNode(expression, 0 /* GeneratedIdentifierFlags.None */, '', '')
+            : factory.createTempVariable(0 /* GeneratedIdentifierFlags.None */);
+        const result = expression instanceof Identifier
+            ? factory.createGeneratedNameForNode(iterator, 0 /* GeneratedIdentifierFlags.None */, '', '')
+            : factory.createTempVariable(0 /* GeneratedIdentifierFlags.None */);
+        const nonUserCode = factory.createTempVariable(0 /* GeneratedIdentifierFlags.None */);
+        const done = factory.createTempVariable(0 /* GeneratedIdentifierFlags.None */);
+        context.addVariableDeclaration(done);
+        const errorRecord = factory.createUniqueName('e', 0 /* GeneratedIdentifierFlags.None */);
+        const catchVariable = factory.createGeneratedNameForNode(errorRecord, 0 /* GeneratedIdentifierFlags.None */, '', '');
+        const returnMethod = factory.createTempVariable(0 /* GeneratedIdentifierFlags.None */);
+        const callValues = createAsyncValuesHelper(factory, expression);
+        callValues.pos = node.expression.pos;
+        callValues.end = node.expression.end;
+        const callNext = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, factory.createIdentifier('next')), []);
+        const getDone = factory.createPropertyAccessExpression(result, factory.createIdentifier('done'));
+        const getValue = factory.createPropertyAccessExpression(result, factory.createIdentifier('value'));
+        const callReturn = factory.createCallExpression(factory.createPropertyAccessExpression(returnMethod, factory.createIdentifier('call')), [iterator]);
+        context.addVariableDeclaration(errorRecord);
+        context.addVariableDeclaration(returnMethod);
+        // In an outer loop, reset the error record on each iteration.
+        const initializer = (ancestorFacts & 2 /* HierarchyFacts.IterationContainer */) !== 0
+            ? factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), callValues])
+            : callValues;
+        const iteratorDeclaration = factory.createVariableDeclaration(iterator, undefined, undefined, initializer);
+        iteratorDeclaration.pos = node.expression.pos;
+        iteratorDeclaration.end = node.expression.end;
+        const declarations = factory.createVariableDeclarationList(factory.createNodeList([
+            factory.createVariableDeclaration(nonUserCode, undefined, undefined, factory.createKeywordExpression(111 /* SyntaxKind.TrueKeyword */)),
+            iteratorDeclaration,
+            factory.createVariableDeclaration(result, undefined, undefined, undefined),
+        ]), 0 /* NodeFlags.None */);
+        declarations.pos = node.expression.pos;
+        declarations.end = node.expression.end;
+        const condition = factory.inlineExpressions([
+            factory.createAssignment(result, this.createDownlevelAwait(callNext)),
+            factory.createAssignment(done, getDone),
+            factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, done),
+        ]);
+        const incrementor = factory.createAssignment(nonUserCode, factory.createKeywordExpression(111 /* SyntaxKind.TrueKeyword */));
+        const forStatement = factory.created(new ForStatement(declarations, condition, incrementor, this.convertForOfStatementHead(node, getValue, nonUserCode)));
+        forStatement.pos = node.pos;
+        forStatement.end = node.end;
+        context.addEmitFlags(forStatement, 64 /* EmitFlags.NoTokenTrailingSourceMaps */);
+        context.setOriginal(forStatement, node);
+        const tryBlock = factory.createBlock([this.restoreEnclosingLabel(forStatement, outermost)], true);
+        // catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        const catchBody = factory.createBlock([
+            factory.createExpressionStatement(factory.createAssignment(errorRecord, factory.createObjectLiteral([factory.createPropertyAssignment(factory.createIdentifier('error'), catchVariable)], false))),
+        ], false);
+        context.addEmitFlags(catchBody, 1 /* EmitFlags.SingleLine */);
+        const catchClause = factory.created(new CatchClause(factory.createVariableDeclaration(catchVariable, undefined, undefined, undefined), catchBody));
+        // if (!nonUserCode && !done && (returnMethod = iterator.return)) await returnMethod.call(iterator);
+        const closeCondition = factory.createBinaryExpression(factory.createBinaryExpression(factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, nonUserCode), 55 /* SyntaxKind.AmpersandAmpersandToken */, factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, done)), 55 /* SyntaxKind.AmpersandAmpersandToken */, factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, factory.createIdentifier('return'))));
+        const close = factory.createIfStatement(closeCondition, factory.createExpressionStatement(this.createDownlevelAwait(callReturn)), undefined);
+        context.addEmitFlags(close, 1 /* EmitFlags.SingleLine */);
+        // if (e_1) throw e_1.error;
+        const rethrow = factory.created(new IfStatement(errorRecord, factory.created(new ThrowStatement(factory.createPropertyAccessExpression(errorRecord, factory.createIdentifier('error')))), undefined));
+        context.addEmitFlags(rethrow, 1 /* EmitFlags.SingleLine */);
+        const innerFinally = factory.createBlock([rethrow], false);
+        context.addEmitFlags(innerFinally, 1 /* EmitFlags.SingleLine */);
+        const innerTry = factory.created(new TryStatement(factory.createBlock([close], false), undefined, innerFinally));
+        return factory.created(new TryStatement(tryBlock, catchClause, factory.createBlock([innerTry], true)));
+    }
+    // Functions
+    visitConstructor(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const updated = this.factory.updateConstructorDeclaration(node, node.modifiers, undefined, this.visitParameters(node.parameters), undefined, undefined, this.visitFunctionBody(node.body));
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    visitGetAccessor(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const updated = this.factory.updateGetAccessorDeclaration(node, node.modifiers, this.visitNode(node.name), undefined, this.visitParameters(node.parameters), undefined, undefined, this.visitFunctionBody(node.body));
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    visitSetAccessor(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const updated = this.factory.updateSetAccessorDeclaration(node, node.modifiers, this.visitNode(node.name), undefined, this.visitParameters(node.parameters), undefined, undefined, this.visitFunctionBody(node.body));
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    /** Modifiers without `async` for generators, whose `async` moves to `__asyncGenerator`. */
+    generatorModifiers(modifiers) {
+        if ((this.enclosingFunctionFlags & 1 /* FunctionFlags.Generator */) === 0)
+            return modifiers;
+        return this.extractModifiers(modifiers, ~1024 /* ModifierFlags.Async */);
+    }
+    visitMethodDeclaration(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const modifiers = this.generatorModifiers(node.modifiers);
+        const asteriskToken = (this.enclosingFunctionFlags & 2 /* FunctionFlags.Async */) !== 0 ? undefined : node.asteriskToken;
+        let parameters;
+        let body;
+        if (this.inAsyncGenerator()) {
+            parameters = this.transformAsyncGeneratorParameterList(node);
+            body = this.transformAsyncGeneratorBody(node);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.visitFunctionBody(node.body);
+        }
+        const updated = this.factory.updateMethodDeclaration(node, modifiers, asteriskToken, this.visitNode(node.name), undefined, undefined, parameters, undefined, undefined, body);
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    visitFunctionDeclaration(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const modifiers = this.generatorModifiers(node.modifiers);
+        const asteriskToken = (this.enclosingFunctionFlags & 2 /* FunctionFlags.Async */) !== 0 ? undefined : node.asteriskToken;
+        let parameters;
+        let body;
+        if (this.inAsyncGenerator()) {
+            parameters = this.transformAsyncGeneratorParameterList(node);
+            body = this.transformAsyncGeneratorBody(node);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.visitFunctionBody(node.body);
+        }
+        const updated = this.factory.updateFunctionDeclaration(node, modifiers, asteriskToken, node.name, undefined, parameters, undefined, undefined, body);
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    visitFunctionExpression(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const modifiers = this.generatorModifiers(node.modifiers);
+        const asteriskToken = (this.enclosingFunctionFlags & 2 /* FunctionFlags.Async */) !== 0 ? undefined : node.asteriskToken;
+        let parameters;
+        let body;
+        if (this.inAsyncGenerator()) {
+            parameters = this.transformAsyncGeneratorParameterList(node);
+            body = this.transformAsyncGeneratorBody(node);
+        }
+        else {
+            parameters = this.visitParameters(node.parameters);
+            body = this.visitFunctionBody(node.body);
+        }
+        const updated = this.factory.updateFunctionExpression(node, modifiers, asteriskToken, node.name, undefined, parameters, undefined, undefined, body);
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    visitArrowFunction(node) {
+        const saved = this.enclosingFunctionFlags;
+        this.enclosingFunctionFlags = getFunctionFlags(node);
+        const updated = this.factory.updateArrowFunction(node, node.modifiers, undefined, this.visitParameters(node.parameters), undefined, undefined, node.equalsGreaterThanToken, this.visitFunctionBody(node.body));
+        this.enclosingFunctionFlags = saved;
+        return updated;
+    }
+    /** The visited parameters if simple, else placeholders up to the first initializer or rest, keeping `length`. */
+    transformAsyncGeneratorParameterList(node) {
+        const list = getParameters(node);
+        if (isSimpleParameterList(list.nodes))
+            return this.visitParameters(list);
+        const factory = this.factory;
+        const parameters = [];
+        for (let i = 0; i < list.nodes.length; i++) {
+            const parameter = list.nodes[i];
+            if (parameter.initializer !== undefined || parameter.dotDotDotToken !== undefined)
+                break;
+            parameters.push(factory.createParameter(factory.createGeneratedNameForNode(parameter.name, 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */, '', '')));
+        }
+        const result = factory.createNodeList(parameters);
+        result.pos = list.pos;
+        result.end = list.end;
+        return result;
+    }
+    transformAsyncGeneratorBody(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const superAccess = this.superAccess;
+        const parameterList = getParameters(node);
+        const innerParameters = isSimpleParameterList(parameterList.nodes)
+            ? undefined
+            : this.visitParameters(parameterList);
+        const saved = superAccess.enter();
+        const body = getBody(node);
+        let asyncBody = factory.updateBlock(body, this.visitNodes(body.statements), body.multiLine);
+        asyncBody = factory.updateBlock(asyncBody, context.mergeEnvironmentList(asyncBody.statements, context.endVariableEnvironment()), asyncBody.multiLine);
+        const emitSuperHelpers = superAccess.needsHelpers();
+        if (emitSuperHelpers)
+            asyncBody = superAccess.visitNode(asyncBody);
+        const name = getName(node);
+        const generator = factory.created(new FunctionExpression(undefined, factory.createToken(41 /* SyntaxKind.AsteriskToken */), name !== undefined
+            ? factory.createGeneratedNameForNode(name, 0 /* GeneratedIdentifierFlags.None */, '', '')
+            : undefined, undefined, innerParameters !== undefined ? innerParameters : factory.createNodeList([]), undefined, undefined, asyncBody));
+        const returnStatement = factory.createReturnStatement(createAsyncGeneratorHelper(factory, generator, (this.hierarchyFacts & 1 /* HierarchyFacts.HasLexicalThis */) !== 0));
+        context.startVariableEnvironment();
+        if (emitSuperHelpers && superAccess.capturedSuperProperties.length > 0)
+            context.addInitializationStatement(superAccess.createSuperAccessVariableStatement());
+        const block = factory.updateBlock(body, factory.createNodeList(context.mergeEnvironment([returnStatement], context.endVariableEnvironment())), body.multiLine);
+        if (emitSuperHelpers && superAccess.hasSuperElementAccess)
+            context.addEmitHelper(block, superAccess.hasSuperPropertyAssignment ? advancedAsyncSuperHelper : asyncSuperHelper);
+        superAccess.exit(saved);
+        return block;
+    }
+}

package/dist/api/compiler/transformers/import-elision.d.ts

@@ -0,0 +1,16 @@
+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 { Transformer } from './transformer.js';
+export declare class ImportElision extends Transformer {
+    readonly options: CompilerOptions;
+    readonly resolver: EmitResolver;
+    private currentSourceFile;
+    constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver);
+    visit(node: Node): Node | undefined;
+    private importAttributes;
+    private shouldEmitAliasDeclaration;
+    private isValueAliasDeclaration;
+    private isTopLevelValueImportEqualsWithEntityName;
+}

package/dist/api/compiler/transformers/import-elision.js

@@ -0,0 +1,124 @@
+// Removes imports used only as types, and exports of types.
+import { ExportAssignment, ExportDeclaration, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, NamedExports, NamedImports, SourceFile, } from '../ast.js';
+import { Transformer } from './transformer.js';
+import { isExternalModule } from './utilities.js';
+export class ImportElision extends Transformer {
+    options;
+    resolver;
+    currentSourceFile;
+    constructor(context, options, resolver) {
+        super(context);
+        this.options = options;
+        this.resolver = resolver;
+        this.currentSourceFile = undefined;
+    }
+    visit(node) {
+        const factory = this.factory;
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile) {
+                    const original = this.context.mostOriginal(node);
+                    if (original instanceof SourceFile)
+                        this.resolver.markLinkedReferences(original);
+                    const saved = this.currentSourceFile;
+                    this.currentSourceFile = node;
+                    const result = this.visitEachChild(node);
+                    this.currentSourceFile = saved;
+                    return result;
+                }
+                break;
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (node instanceof ImportEqualsDeclaration) {
+                    const keep = node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */
+                        ? this.shouldEmitAliasDeclaration(node)
+                        : this.shouldEmitAliasDeclaration(node) ||
+                            (this.currentSourceFile !== undefined &&
+                                !isExternalModule(this.currentSourceFile) &&
+                                this.isTopLevelValueImportEqualsWithEntityName(node));
+                    return keep ? this.visitEachChild(node) : undefined;
+                }
+                break;
+            case 273 /* SyntaxKind.ImportDeclaration */:
+                if (node instanceof ImportDeclaration) {
+                    if (node.importClause === undefined)
+                        return this.visitEachChild(node);
+                    const clause = this.visitNode(node.importClause);
+                    if (!(clause instanceof ImportClause))
+                        return undefined;
+                    const importClause = clause;
+                    return factory.updateImportDeclaration(node, node.modifiers, importClause, node.moduleSpecifier, this.importAttributes(node.attributes));
+                }
+                break;
+            case 274 /* SyntaxKind.ImportClause */:
+                if (node instanceof ImportClause) {
+                    const name = this.shouldEmitAliasDeclaration(node) ? node.name : undefined;
+                    const bindings = this.visitNode(node.namedBindings);
+                    if (name === undefined && bindings === undefined)
+                        return undefined;
+                    return factory.updateImportClause(node, node.phaseModifier, name, bindings);
+                }
+                break;
+            case 275 /* SyntaxKind.NamespaceImport */:
+            case 277 /* SyntaxKind.ImportSpecifier */:
+                return this.shouldEmitAliasDeclaration(node) ? node : undefined;
+            case 276 /* SyntaxKind.NamedImports */:
+                if (node instanceof NamedImports) {
+                    const elements = this.visitNodes(node.elements);
+                    return elements.nodes.length === 0 ? undefined : factory.updateNamedImports(node, elements);
+                }
+                break;
+            case 278 /* SyntaxKind.ExportAssignment */:
+                if (node instanceof ExportAssignment) {
+                    if (this.options.verbatimModuleSyntax !== true && !this.isValueAliasDeclaration(node))
+                        return undefined;
+                    return this.visitEachChild(node);
+                }
+                break;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                if (node instanceof ExportDeclaration) {
+                    let clause = undefined;
+                    if (node.exportClause !== undefined) {
+                        clause = this.visitNode(node.exportClause);
+                        if (clause === undefined)
+                            return undefined;
+                    }
+                    return factory.updateExportDeclaration(node, undefined, false, clause, this.visitNode(node.moduleSpecifier), this.importAttributes(node.attributes));
+                }
+                break;
+            case 280 /* SyntaxKind.NamedExports */:
+                if (node instanceof NamedExports) {
+                    const elements = this.visitNodes(node.elements);
+                    return elements.nodes.length === 0 ? undefined : factory.updateNamedExports(node, elements);
+                }
+                break;
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                return this.isValueAliasDeclaration(node) ? node : undefined;
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleBlock */:
+                return this.visitEachChild(node);
+        }
+        return node;
+    }
+    importAttributes(node) {
+        const visited = this.visitNode(node);
+        if (visited === undefined)
+            return undefined;
+        if (visited instanceof ImportAttributes)
+            return visited;
+        throw new Error('Expected import attributes');
+    }
+    shouldEmitAliasDeclaration(node) {
+        if ((node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0)
+            return true;
+        const parseNode = this.context.parseNode(node);
+        return parseNode === undefined || this.resolver.isReferencedAliasDeclaration(parseNode);
+    }
+    isValueAliasDeclaration(node) {
+        const parseNode = this.context.parseNode(node);
+        return parseNode === undefined || this.resolver.isValueAliasDeclaration(parseNode);
+    }
+    isTopLevelValueImportEqualsWithEntityName(node) {
+        const parseNode = this.context.parseNode(node);
+        return parseNode !== undefined && this.resolver.isTopLevelValueImportEqualsWithEntityName(parseNode);
+    }
+}

package/dist/api/compiler/transformers/jsx-entities.d.ts

@@ -0,0 +1 @@
+export declare const entities: Map<string, number>;