tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/commonjs-module.js

@@ -0,0 +1,1180 @@
+// CommonJS module output: imports become `require` calls, exports assignments to `exports`.
+import { ArrowFunction, BinaryExpression, BindingPattern, Block, CallExpression, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, DoStatement, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, LabeledStatement, NamedExports, NamespaceExport, NodeList, NodeVisitor, ObjectLiteralExpression, ArrayLiteralExpression, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateSpan, TemplateTail, TryStatement, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, EmptyStatement, getElements, getName, } from '../ast.js';
+import { getExternalModuleName, isImportCall, isInJSFile, isRequireCall } from '../ast-utilities.js';
+import { isAssignmentExpression, isDestructuringAssignment } from '../binder-utilities.js';
+import { JsxEmit, ModuleKind, ScriptTarget, getEmitModuleKind, getEmitScriptTarget, } from '../options.js';
+import { isPrologueDirective } from '../printer/utilities.js';
+import { fileExtensionIsOneOf } from '../path.js';
+import { AssignmentFactory, convertVariableDeclarationToAssignment, flattenDestructuringAssignment, isSimpleCopiableExpression, } from './destructuring.js';
+import { collectExternalModuleInfo, createExternalHelpersImportDeclarationIfNeeded, getImportNeedsImportDefaultHelper, getImportNeedsImportStarHelper, getNamespaceDeclarationNode, isDefaultImport, isEffectiveExternalModule, moduleExportNameText, } from './external-module-info.js';
+import { Transformer } from './transformer.js';
+import { hasSyntacticModifier, isExternalModule, isIdentifierReference, singleOrMany } from './utilities.js';
+import { VisitorBase } from './visitor-base.js';
+import { createRequireCallArguments, rewriteModuleSpecifier } from './module-utilities.js';
+const exportDefault = 32 /* ModifierFlags.Export */ | 2048 /* ModifierFlags.Default */;
+const supportedJSExtensions = ['.js', '.jsx', '.mjs', '.cjs'];
+/** 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);
+    }
+}
+/** Assigns flattened destructuring targets that are exported to `exports.x` as well. */
+class ExportAssignments extends AssignmentFactory {
+    owner;
+    constructor(owner) {
+        super();
+        this.owner = owner;
+    }
+    createAssignment(name, value, pos, end) {
+        return this.owner.createAllExportExpressions(name, value, pos, end);
+    }
+}
+export class CommonJSModuleTransformer extends Transformer {
+    options;
+    resolver;
+    formats;
+    moduleKind;
+    languageVersion;
+    topLevel;
+    topLevelNested;
+    discarded;
+    exportAssignments;
+    currentSourceFile;
+    info;
+    parentNode;
+    currentNode;
+    constructor(context, options, resolver, formats) {
+        super(context);
+        this.options = options;
+        this.resolver = resolver;
+        this.formats = formats;
+        this.moduleKind = getEmitModuleKind(options);
+        this.languageVersion = getEmitScriptTarget(options);
+        this.topLevel = new ModeVisitor(this, 0 /* VisitMode.TopLevel */);
+        this.topLevelNested = new ModeVisitor(this, 1 /* VisitMode.TopLevelNested */);
+        this.discarded = new ModeVisitor(this, 2 /* VisitMode.DiscardedValue */);
+        this.exportAssignments = new ExportAssignments(this);
+        this.currentSourceFile = undefined;
+        this.info = undefined;
+        this.parentNode = undefined;
+        this.currentNode = undefined;
+    }
+    moduleInfo() {
+        return this.info;
+    }
+    // Visitors
+    visit(node) {
+        const grandparent = this.pushNode(node);
+        const result = this.visitNoStack(node, false);
+        this.popNode(grandparent);
+        return result;
+    }
+    visitInMode(mode, node) {
+        if (mode === 0 /* VisitMode.TopLevel */)
+            return this.visitTopLevel(node);
+        const grandparent = this.pushNode(node);
+        const result = mode === 1 /* VisitMode.TopLevelNested */ ? this.visitTopLevelNestedNoStack(node) : this.visitNoStack(node, true);
+        this.popNode(grandparent);
+        return result;
+    }
+    pushNode(node) {
+        const grandparent = this.parentNode;
+        this.parentNode = this.currentNode;
+        this.currentNode = node;
+        return grandparent;
+    }
+    popNode(grandparent) {
+        this.currentNode = this.parentNode;
+        this.parentNode = grandparent;
+        return true;
+    }
+    visitTopLevel(node) {
+        const grandparent = this.pushNode(node);
+        let result;
+        if (node instanceof ImportDeclaration)
+            result = this.visitTopLevelImportDeclaration(node);
+        else if (node instanceof ImportEqualsDeclaration)
+            result = this.visitTopLevelImportEqualsDeclaration(node);
+        else if (node instanceof ExportDeclaration)
+            result = this.visitTopLevelExportDeclaration(node);
+        else if (node instanceof ExportAssignment)
+            result = this.visitTopLevelExportAssignment(node);
+        else if (node instanceof FunctionDeclaration)
+            result = this.visitTopLevelFunctionDeclaration(node);
+        else if (node instanceof ClassDeclaration)
+            result = this.visitTopLevelClassDeclaration(node);
+        else if (node instanceof VariableStatement)
+            result = this.visitTopLevelVariableStatement(node);
+        else
+            result = this.visitTopLevelNestedNoStack(node);
+        this.popNode(grandparent);
+        return result;
+    }
+    visitTopLevelNestedNoStack(node) {
+        const factory = this.factory;
+        const nested = this.topLevelNested;
+        if (node instanceof VariableStatement)
+            return this.visitTopLevelVariableStatement(node);
+        if (node instanceof ForStatement)
+            return this.visitTopLevelNestedForStatement(node);
+        if (node instanceof ForInOrOfStatement)
+            return this.visitTopLevelNestedForInOrOfStatement(node);
+        if (node instanceof DoStatement)
+            return factory.updateDoStatement(node, nested.visitIterationBody(node.statement), this.visitNode(node.expression));
+        if (node instanceof WhileStatement)
+            return factory.updateWhileStatement(node, this.visitNode(node.expression), nested.visitIterationBody(node.statement));
+        if (node instanceof LabeledStatement) {
+            const statement = nested.visitStatement(node.statement);
+            return factory.updateLabeledStatement(node, node.label, statement !== undefined ? statement : factory.created(new EmptyStatement()));
+        }
+        if (node instanceof WithStatement)
+            return factory.updateWithStatement(node, this.visitNode(node.expression), nested.visitStatement(node.statement));
+        if (node instanceof IfStatement) {
+            const thenStatement = nested.visitStatement(node.thenStatement);
+            return factory.updateIfStatement(node, this.visitNode(node.expression), thenStatement !== undefined ? thenStatement : factory.createBlock([], false), nested.visitStatement(node.elseStatement));
+        }
+        if (node instanceof SwitchStatement) {
+            const caseBlock = nested.visitNode(node.caseBlock);
+            return factory.updateSwitchStatement(node, this.visitNode(node.expression), caseBlock instanceof CaseBlock ? caseBlock : node.caseBlock);
+        }
+        if (node instanceof CaseBlock || node instanceof TryStatement || node instanceof Block)
+            return nested.visitEachChild(node);
+        if (node instanceof CaseOrDefaultClause)
+            return factory.updateCaseOrDefaultClause(node, this.visitNode(node.expression), nested.visitNodes(node.statements));
+        if (node instanceof CatchClause) {
+            const block = nested.visitNode(node.block);
+            return factory.updateCatchClause(node, node.variableDeclaration, block instanceof Block ? block : node.block);
+        }
+        return this.visitNoStack(node, false);
+    }
+    /** Visits a node other than a top-level statement; `discarded` if its value is unused. */
+    visitNoStack(node, discarded) {
+        if (node instanceof SourceFile)
+            return this.visitSourceFile(node);
+        if (node instanceof ForStatement)
+            return this.factory.updateForStatement(node, this.discarded.visitNode(node.initializer), this.visitNode(node.condition), this.discarded.visitNode(node.incrementor), this.topLevelNested.visitIterationBody(node.statement));
+        if (node instanceof ForInOrOfStatement)
+            return this.factory.updateForInOrOfStatement(node, node.awaitModifier, this.discarded.visitNode(node.initializer), this.visitNode(node.expression), this.topLevelNested.visitIterationBody(node.statement));
+        if (node instanceof ExpressionStatement || node instanceof VoidExpression)
+            return this.discarded.visitEachChild(node);
+        if (node instanceof ParenthesizedExpression)
+            return this.factory.updateParenthesizedExpression(node, (discarded ? this.discarded.visitNode(node.expression) : this.visitNode(node.expression)));
+        if (node instanceof PartiallyEmittedExpression)
+            return this.factory.updatePartiallyEmittedExpression(node, (discarded ? this.discarded.visitNode(node.expression) : this.visitNode(node.expression)));
+        if (node instanceof CallExpression)
+            return this.visitCallExpression(node);
+        if (node instanceof TaggedTemplateExpression)
+            return this.visitTaggedTemplateExpression(node);
+        if (node instanceof BinaryExpression)
+            return this.visitBinaryExpression(node, discarded);
+        if (node instanceof PrefixUnaryExpression)
+            return this.visitPrefixUnaryExpression(node);
+        if (node instanceof PostfixUnaryExpression)
+            return this.visitPostfixUnaryExpression(node, discarded);
+        if (node instanceof ShorthandPropertyAssignment)
+            return this.visitShorthandPropertyAssignment(node);
+        if (node instanceof Identifier)
+            return isIdentifierReference(node, this.parentNode) ? this.visitExpressionIdentifier(node) : node;
+        return this.visitEachChild(node);
+    }
+    // Source files
+    visitSourceFile(node) {
+        if (node.isDeclarationFile || !(isEffectiveExternalModule(node, this.options) || containsDynamicImport(node)))
+            return node;
+        this.currentSourceFile = node;
+        this.info = collectExternalModuleInfo(node, this.context, this.resolver);
+        const updated = this.transformCommonJSModule(node);
+        this.currentSourceFile = undefined;
+        this.info = undefined;
+        return updated;
+    }
+    shouldEmitUnderscoreUnderscoreESModule(file) {
+        if (fileExtensionIsOneOf(file.fileName, supportedJSExtensions) &&
+            file.commonJSModuleIndicator !== undefined &&
+            (file.externalModuleIndicator === undefined || file.externalModuleIndicator.kind === 307 /* SyntaxKind.SourceFile */))
+            return false;
+        return this.moduleInfo().exportEquals === undefined && isExternalModule(file);
+    }
+    /** `Object.defineProperty(exports, "__esModule", { value: true });` */
+    createUnderscoreUnderscoreESModule() {
+        const factory = this.factory;
+        const statement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Object'), factory.createIdentifier('defineProperty')), [
+            factory.createIdentifier('exports'),
+            factory.createStringLiteral('__esModule', 0 /* TokenFlags.None */),
+            factory.createObjectLiteral([factory.createPropertyAssignment(factory.createIdentifier('value'), factory.createTrue())], false),
+        ]));
+        this.context.setEmitFlags(statement, 65536 /* EmitFlags.CustomPrologue */);
+        return statement;
+    }
+    transformCommonJSModule(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const info = this.moduleInfo();
+        context.startVariableEnvironment();
+        const source = node.statements.nodes;
+        const prologueEnd = standardPrologueEnd(source);
+        const statements = source.slice(0, prologueEnd);
+        const customEnd = this.customPrologueEnd(source, prologueEnd);
+        appendAll(statements, this.topLevel.visitArray(source.slice(prologueEnd, customEnd)));
+        if (this.shouldEmitUnderscoreUnderscoreESModule(node))
+            statements.push(this.createUnderscoreUnderscoreESModule());
+        // exports.a = exports.b = void 0;
+        const names = info.exportedNames;
+        for (let start = 0; start < names.length; start += 50) {
+            let right = factory.createVoidZero();
+            const end = Math.min(start + 50, names.length);
+            for (let i = start; i < end; i++)
+                right = factory.createAssignment(this.createExportsReference(names[i]), right);
+            const statement = factory.createExpressionStatement(right);
+            context.addEmitFlags(statement, 65536 /* EmitFlags.CustomPrologue */);
+            statements.push(statement);
+        }
+        // exports.f = f; ahead of the helpers import, as TypeScript orders them.
+        const functionsStart = statements.length;
+        for (let i = 0; i < info.exportedFunctions.length; i++)
+            this.appendExportsOfClassOrFunctionDeclaration(statements, info.exportedFunctions[i]);
+        for (let i = functionsStart; i < statements.length; i++)
+            context.addEmitFlags(statements[i], 65536 /* EmitFlags.CustomPrologue */);
+        appendAll(statements, this.topLevel.visitArray(source.slice(customEnd)));
+        this.appendExportEqualsIfNeeded(statements);
+        const merged = context.mergeEnvironment(statements, context.endVariableEnvironment());
+        let result = factory.updateSourceFile(node, new NodeList(node.statements.pos, node.statements.end, merged), node.endOfFileToken);
+        const helpers = context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            context.addEmitHelper(result, helpers[i]);
+        const helpersImport = createExternalHelpersImportDeclarationIfNeeded(context, result, this.options, this.formats.getEmitModuleFormat(node.fileName));
+        if (helpersImport !== undefined) {
+            const current = result.statements.nodes;
+            const standardEnd = standardPrologueEnd(current);
+            const end = this.customPrologueEnd(current, standardEnd);
+            const withImport = current.slice(0, end);
+            const visited = this.topLevel.visitNode(helpersImport);
+            if (visited !== undefined)
+                withImport.push(visited);
+            appendAll(withImport, current.slice(end));
+            result = factory.updateSourceFile(result, new NodeList(result.statements.pos, result.statements.end, withImport), node.endOfFileToken);
+        }
+        return result;
+    }
+    customPrologueEnd(statements, start) {
+        let i = start;
+        while (i < statements.length &&
+            !isPrologueDirective(statements[i]) &&
+            (this.context.getEmitFlags(statements[i]) & 65536 /* EmitFlags.CustomPrologue */) !== 0)
+            i++;
+        return i;
+    }
+    /** `exports.x` or `exports["x"]` for an export name. */
+    createExportsReference(name) {
+        const factory = this.factory;
+        if (name instanceof StringLiteral)
+            return factory.createElementAccessExpression(factory.createIdentifier('exports'), factory.createStringLiteralFromNode(name));
+        const clone = this.cloneName(name);
+        this.context.setEmitFlags(clone, 12 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoComments */);
+        return factory.createPropertyAccessExpression(factory.createIdentifier('exports'), clone);
+    }
+    cloneName(name) {
+        return name instanceof Identifier ? this.factory.cloneIdentifier(name) : name;
+    }
+    /** `module.exports = x;` for `export = x`. */
+    appendExportEqualsIfNeeded(statements) {
+        const exportEquals = this.moduleInfo().exportEquals;
+        if (exportEquals === undefined)
+            return false;
+        const grandparent = this.pushNode(exportEquals);
+        const expression = this.visitNode(exportEquals.expression);
+        this.popNode(grandparent);
+        if (expression === undefined)
+            return false;
+        const factory = this.factory;
+        const statement = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('module'), factory.createIdentifier('exports')), expression));
+        this.context.assignCommentAndSourceMapRanges(statement, exportEquals);
+        this.context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+        statements.push(statement);
+        return true;
+    }
+    // Exports of declarations
+    appendExportsOfImportDeclaration(statements, declaration) {
+        if (this.moduleInfo().exportEquals !== undefined)
+            return false;
+        const clause = declaration.importClause;
+        if (clause === undefined)
+            return false;
+        const seen = new Set();
+        if (clause.name !== undefined)
+            this.appendExportsOfDeclaration(statements, clause, seen, false);
+        const bindings = clause.namedBindings;
+        if (bindings !== undefined && bindings.kind === 275 /* SyntaxKind.NamespaceImport */)
+            this.appendExportsOfDeclaration(statements, bindings, seen, false);
+        else if (bindings !== undefined && bindings.kind === 276 /* SyntaxKind.NamedImports */) {
+            const elements = bindingElementsOf(bindings);
+            for (let i = 0; i < elements.length; i++)
+                this.appendExportsOfDeclaration(statements, elements[i], seen, true);
+        }
+        return true;
+    }
+    appendExportsOfVariableDeclarationList(statements, list, isForInOrOfInitializer) {
+        if (this.moduleInfo().exportEquals !== undefined)
+            return false;
+        const declarations = list.declarations.nodes;
+        for (let i = 0; i < declarations.length; i++)
+            this.appendExportsOfBindingElement(statements, declarations[i], isForInOrOfInitializer);
+        return true;
+    }
+    appendExportsOfBindingElement(statements, declaration, isForInOrOfInitializer) {
+        if (this.moduleInfo().exportEquals !== undefined)
+            return false;
+        const name = bindingNameOf(declaration);
+        if (name === undefined)
+            return false;
+        if (name instanceof BindingPattern) {
+            const elements = name.elements.nodes;
+            for (let i = 0; i < elements.length; i++)
+                if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */)
+                    this.appendExportsOfBindingElement(statements, elements[i], isForInOrOfInitializer);
+            return true;
+        }
+        if (!this.context.hasAutoGenerateInfo(name) &&
+            (!(declaration instanceof VariableDeclaration) || declaration.initializer !== undefined || isForInOrOfInitializer))
+            this.appendExportsOfDeclaration(statements, declaration, undefined, false);
+        return true;
+    }
+    appendExportsOfClassOrFunctionDeclaration(statements, declaration) {
+        if (this.moduleInfo().exportEquals !== undefined)
+            return false;
+        const seen = new Set();
+        if (hasSyntacticModifier(declaration, 32 /* ModifierFlags.Export */)) {
+            const exportName = hasSyntacticModifier(declaration, 2048 /* ModifierFlags.Default */)
+                ? this.factory.createIdentifier('default')
+                : this.factory.getDeclarationName(declaration, 0 /* NameOptions.None */);
+            this.appendExportStatement(statements, seen, exportName, this.factory.getLocalName(declaration, 0 /* NameOptions.None */), declaration, false, false);
+        }
+        if (declarationNameOf(declaration) !== undefined)
+            this.appendExportsOfDeclaration(statements, declaration, seen, false);
+        return true;
+    }
+    appendExportsOfDeclaration(statements, declaration, seenNames, liveBinding) {
+        const info = this.moduleInfo();
+        if (info.exportEquals !== undefined)
+            return false;
+        const seen = seenNames !== undefined ? seenNames : new Set();
+        if (info.exportSpecifiers.size === 0 || !(declarationNameOf(declaration) instanceof Identifier))
+            return false;
+        const name = this.factory.getDeclarationName(declaration, 0 /* NameOptions.None */);
+        const specifiers = info.exportSpecifiers.get(name.text);
+        if (specifiers === undefined || specifiers.length === 0)
+            return false;
+        const value = this.visitExpressionIdentifier(name);
+        for (let i = 0; i < specifiers.length; i++)
+            this.appendExportStatement(statements, seen, specifiers[i].name, value, specifiers[i].name, false, liveBinding);
+        return true;
+    }
+    appendExportStatement(statements, seen, exportName, value, location, allowComments, liveBinding) {
+        if (!(exportName instanceof StringLiteral)) {
+            const text = moduleExportNameText(exportName);
+            if (seen.has(text))
+                return false;
+            seen.add(text);
+        }
+        statements.push(this.createExportStatement(exportName, value, location, allowComments, liveBinding));
+        return true;
+    }
+    createExportStatement(name, value, location, allowComments, liveBinding) {
+        const statement = this.factory.createExpressionStatement(this.createExportExpression(name, value, undefined, liveBinding));
+        if (location !== undefined)
+            this.context.setCommentRange(statement, location.pos, location.end);
+        this.context.addEmitFlags(statement, 524288 /* EmitFlags.StartOnNewLine */);
+        if (!allowComments)
+            this.context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+        return statement;
+    }
+    /** `exports.x = value`, or a getter on `exports` for a live binding. */
+    createExportExpression(name, value, location, liveBinding) {
+        const factory = this.factory;
+        let expression;
+        if (liveBinding) {
+            // Object.defineProperty(exports, "x", { enumerable: true, get: function () { return value; } })
+            const getter = factory.createFunctionExpression([], factory.createBlock([factory.createReturnStatement(value)], false));
+            expression = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Object'), factory.createIdentifier('defineProperty')), [
+                factory.createIdentifier('exports'),
+                factory.createStringLiteralFromNode(name),
+                factory.createObjectLiteral([
+                    factory.createPropertyAssignment(factory.createIdentifier('enumerable'), factory.createTrue()),
+                    factory.createPropertyAssignment(factory.createIdentifier('get'), getter),
+                ], false),
+            ]);
+        }
+        else {
+            const target = name instanceof StringLiteral
+                ? factory.createElementAccessExpression(factory.createIdentifier('exports'), factory.createStringLiteralFromNode(name))
+                : factory.createPropertyAccessExpression(factory.createIdentifier('exports'), this.cloneName(name));
+            expression = factory.createAssignment(target, value);
+        }
+        if (location !== undefined)
+            this.context.setCommentRange(expression, location.pos, location.end);
+        return expression;
+    }
+    /** `require("mod")` */
+    createRequireCall(node) {
+        const factory = this.factory;
+        return factory.createCallExpression(factory.createIdentifier('require'), createRequireCallArguments(this.context, node, this.options));
+    }
+    getHelperExpressionForImport(node, inner) {
+        if (getImportNeedsImportStarHelper(node))
+            return this.visitNode(this.factory.createImportStarHelper(inner));
+        if (getImportNeedsImportDefaultHelper(node))
+            return this.visitNode(this.factory.createImportDefaultHelper(inner));
+        return inner;
+    }
+    // Top-level statements
+    visitTopLevelImportDeclaration(node) {
+        const factory = this.factory;
+        const context = this.context;
+        if (node.importClause === undefined) {
+            // import "mod";
+            const statement = factory.createExpressionStatement(this.createRequireCall(node));
+            context.setOriginal(statement, node);
+            context.assignCommentAndSourceMapRanges(statement, node);
+            return statement;
+        }
+        const variables = [];
+        const namespaceDeclaration = getNamespaceDeclarationNode(node);
+        if (namespaceDeclaration !== undefined && !isDefaultImport(node)) {
+            // import * as n from "mod";
+            variables.push(factory.createVariableDeclaration(this.cloneName(namespaceNameOf(namespaceDeclaration)), undefined, undefined, this.getHelperExpressionForImport(node, this.createRequireCall(node))));
+        }
+        else {
+            // import d, { x } from "mod";
+            variables.push(factory.createVariableDeclaration(factory.createGeneratedNameForNode(node, 0, '', ''), undefined, undefined, this.getHelperExpressionForImport(node, this.createRequireCall(node))));
+            if (namespaceDeclaration !== undefined)
+                variables.push(factory.createVariableDeclaration(this.cloneName(namespaceNameOf(namespaceDeclaration)), undefined, undefined, factory.createGeneratedNameForNode(node, 0, '', '')));
+        }
+        const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList(variables), 2 /* NodeFlags.Const */));
+        context.setOriginal(statement, node);
+        context.assignCommentAndSourceMapRanges(statement, node);
+        const statements = [statement];
+        this.appendExportsOfImportDeclaration(statements, node);
+        return singleOrMany(statements, factory);
+    }
+    visitTopLevelImportEqualsDeclaration(node) {
+        const factory = this.factory;
+        const context = this.context;
+        if (!(node.moduleReference instanceof ExternalModuleReference))
+            return this.visitEachChild(node);
+        let statement;
+        if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */)) {
+            // export import m = require("mod");
+            statement = factory.createExpressionStatement(this.createExportExpression(node.name, this.createRequireCall(node), node, false));
+        }
+        else {
+            // import m = require("mod");
+            statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+                factory.createVariableDeclaration(factory.cloneIdentifier(node.name), undefined, undefined, this.createRequireCall(node)),
+            ]), 2 /* NodeFlags.Const */));
+        }
+        context.setOriginal(statement, node);
+        context.assignCommentAndSourceMapRanges(statement, node);
+        const statements = [statement];
+        this.appendExportsOfDeclaration(statements, node, undefined, false);
+        return singleOrMany(statements, factory);
+    }
+    visitTopLevelExportDeclaration(node) {
+        const factory = this.factory;
+        const context = this.context;
+        // Local `export { x }` is handled with the declarations it exports.
+        if (node.moduleSpecifier === undefined)
+            return undefined;
+        const generatedName = factory.createGeneratedNameForNode(node, 0, '', '');
+        const clause = node.exportClause;
+        if (clause instanceof NamedExports) {
+            // export { x, y } from "mod";
+            const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+                factory.createVariableDeclaration(generatedName, undefined, undefined, this.createRequireCall(node)),
+            ]), 0 /* NodeFlags.None */));
+            context.setOriginal(statement, node);
+            context.assignCommentAndSourceMapRanges(statement, node);
+            const statements = [statement];
+            const specifiers = clause.elements.nodes;
+            for (let i = 0; i < specifiers.length; i++) {
+                const specifier = specifiers[i];
+                if (!(specifier instanceof ExportSpecifier))
+                    continue;
+                const imported = specifier.propertyName !== undefined ? specifier.propertyName : specifier.name;
+                const target = moduleExportNameText(imported) === 'default'
+                    ? factory.createImportDefaultHelper(generatedName)
+                    : generatedName;
+                const exportName = specifier.name instanceof StringLiteral
+                    ? factory.createStringLiteralFromNode(specifier.name)
+                    : factory.getExportName(specifier, 0 /* NameOptions.None */);
+                const value = imported instanceof StringLiteral
+                    ? factory.createElementAccessExpression(target, imported)
+                    : factory.createPropertyAccessExpression(target, imported);
+                const exportStatement = factory.createExpressionStatement(this.createExportExpression(exportName, value, undefined, true));
+                context.setOriginal(exportStatement, specifier);
+                context.assignCommentAndSourceMapRanges(exportStatement, specifier);
+                statements.push(exportStatement);
+            }
+            return singleOrMany(statements, factory);
+        }
+        if (clause instanceof NamespaceExport) {
+            // export * as ns from "mod";
+            const name = clause.name;
+            const exportName = name instanceof StringLiteral ? factory.createStringLiteralFromNode(name) : this.cloneName(name);
+            const statement = factory.createExpressionStatement(this.createExportExpression(exportName, this.visitNode(factory.createImportStarHelper(this.createRequireCall(node))), undefined, false));
+            context.setOriginal(statement, node);
+            context.assignCommentAndSourceMapRanges(statement, node);
+            return statement;
+        }
+        // export * from "mod";
+        const statement = factory.createExpressionStatement(this.visitNode(factory.createExportStarHelper(this.createRequireCall(node), factory.createIdentifier('exports'))));
+        context.setOriginal(statement, node);
+        context.assignCommentAndSourceMapRanges(statement, node);
+        return statement;
+    }
+    visitTopLevelExportAssignment(node) {
+        if (node.isExportEquals)
+            return undefined;
+        return this.createExportStatement(this.factory.createIdentifier('default'), this.visitNode(node.expression), node, true, false);
+    }
+    visitTopLevelFunctionDeclaration(node) {
+        if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+            return this.visitEachChild(node);
+        return this.factory.updateFunctionDeclaration(node, this.extractModifiers(node.modifiers, ~exportDefault), node.asteriskToken, this.factory.getDeclarationName(node, 0 /* NameOptions.None */), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
+    }
+    visitTopLevelClassDeclaration(node) {
+        const statements = [];
+        if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */)) {
+            const updated = this.factory.updateClassDeclaration(node, this.visitModifiers(this.extractModifiers(node.modifiers, ~exportDefault)), this.factory.getDeclarationName(node, 0 /* NameOptions.None */), undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
+            if (updated !== undefined)
+                statements.push(updated);
+        }
+        else
+            statements.push(this.visitEachChild(node));
+        this.appendExportsOfClassOrFunctionDeclaration(statements, node);
+        return singleOrMany(statements, this.factory);
+    }
+    visitTopLevelVariableStatement(node) {
+        if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */)) {
+            // Nested `var`s may still be exported with `export { x }`.
+            const statements = [this.visitEachChild(node)];
+            this.appendExportsOfVariableDeclarationList(statements, node.declarationList, false);
+            return singleOrMany(statements, this.factory);
+        }
+        // export var a = b;  becomes  exports.a = b;
+        const factory = this.factory;
+        const context = this.context;
+        const splitter = new ExportedVariableSplitter(this, node);
+        const declarations = node.declarationList.declarations.nodes;
+        for (let i = 0; i < declarations.length; i++) {
+            const variable = declarations[i];
+            if (!(variable instanceof VariableDeclaration))
+                continue;
+            const name = variable.name;
+            const initializer = variable.initializer;
+            if (name instanceof Identifier && (context.getEmitFlags(name) & 4096 /* EmitFlags.LocalName */) !== 0) {
+                // A class or function converted to a variable: references stay local, an `export { x }` follows.
+                splitter.ensureModifiers();
+                splitter.pushVariable(initializer === undefined
+                    ? variable
+                    : factory.updateVariableDeclaration(variable, name, undefined, undefined, this.createExportExpression(name, this.visitNode(initializer), undefined, false)));
+            }
+            else if (initializer !== undefined &&
+                !(name instanceof BindingPattern) &&
+                (initializer instanceof ArrowFunction ||
+                    initializer instanceof FunctionExpression ||
+                    initializer instanceof ClassExpression)) {
+                // Variables keep functions and classes named.
+                splitter.pushVariable(factory.createVariableDeclaration(name, variable.exclamationToken, variable.type, this.visitNode(initializer)));
+                const access = factory.createPropertyAccessExpression(factory.createIdentifier('exports'), name);
+                context.assignCommentAndSourceMapRanges(access, name);
+                splitter.pushExpression(factory.createAssignment(access, this.cloneName(name)));
+            }
+            else if (name instanceof Identifier) {
+                const expression = this.transformInitializedVariable(variable);
+                if (expression !== undefined)
+                    splitter.pushExpression(this.visitNode(expression));
+            }
+            else if (name instanceof BindingPattern) {
+                const expression = this.transformInitializedVariable(variable);
+                if (expression !== undefined)
+                    splitter.pushExpression(expression);
+            }
+            else {
+                const expression = convertVariableDeclarationToAssignment(this, variable);
+                if (expression !== undefined)
+                    splitter.pushExpression(this.visitNode(expression));
+            }
+        }
+        splitter.commitVariables();
+        splitter.commitExpressions();
+        const statements = splitter.statements;
+        this.appendExportsOfVariableDeclarationList(statements, node.declarationList, false);
+        return singleOrMany(statements, factory);
+    }
+    transformInitializedVariable(node) {
+        const initializer = node.initializer;
+        if (initializer === undefined)
+            return undefined;
+        const name = node.name;
+        if (name instanceof BindingPattern) {
+            // Kept as native destructuring unless a target can't be rewritten to `exports.x`.
+            const assignment = convertVariableDeclarationToAssignment(this, node);
+            const grandparent = this.pushNode(assignment);
+            const result = assignment instanceof BinaryExpression ? this.visitDestructuringAssignment(assignment, true) : assignment;
+            this.popNode(grandparent);
+            return result;
+        }
+        const access = this.factory.createPropertyAccessExpression(this.factory.createIdentifier('exports'), name);
+        this.context.assignCommentAndSourceMapRanges(access, name);
+        return this.factory.createAssignment(access, initializer);
+    }
+    visitTopLevelNestedForStatement(node) {
+        const factory = this.factory;
+        const initializer = node.initializer;
+        if (initializer instanceof VariableDeclarationList && (initializer.flags & 7 /* NodeFlags.BlockScoped */) === 0) {
+            const exports = [];
+            this.appendExportsOfVariableDeclarationList(exports, initializer, false);
+            if (exports.length > 0) {
+                // var x = 0; exports.x = x; for (; ;) { }
+                const list = this.discarded.visitNode(initializer);
+                const statements = [
+                    factory.createVariableStatement(undefined, list instanceof VariableDeclarationList
+                        ? list
+                        : initializer),
+                ];
+                appendAll(statements, exports);
+                const updated = factory.updateForStatement(node, undefined, this.visitNode(node.condition), this.discarded.visitNode(node.incrementor), this.topLevelNested.visitIterationBody(node.statement));
+                if (updated !== undefined)
+                    statements.push(updated);
+                return singleOrMany(statements, factory);
+            }
+        }
+        return factory.updateForStatement(node, this.discarded.visitNode(initializer), this.visitNode(node.condition), this.discarded.visitNode(node.incrementor), this.topLevelNested.visitIterationBody(node.statement));
+    }
+    visitTopLevelNestedForInOrOfStatement(node) {
+        const factory = this.factory;
+        const initializer = node.initializer;
+        if (initializer instanceof VariableDeclarationList && (initializer.flags & 7 /* NodeFlags.BlockScoped */) === 0) {
+            const exports = [];
+            this.appendExportsOfVariableDeclarationList(exports, initializer, true);
+            if (exports.length > 0) {
+                // for (var x in y) { exports.x = x; ... }
+                const visitedInitializer = this.discarded.visitNode(initializer);
+                const expression = this.visitNode(node.expression);
+                const body = this.topLevelNested.visitIterationBody(node.statement);
+                let updatedBody;
+                if (body instanceof Block) {
+                    const block = factory.updateBlock(body, new NodeList(body.statements.pos, body.statements.end, exports.concat(body.statements.nodes)), body.multiLine);
+                    updatedBody = block !== undefined ? block : body;
+                }
+                else {
+                    exports.push(body);
+                    updatedBody = factory.createBlock(exports, true);
+                }
+                return factory.updateForInOrOfStatement(node, node.awaitModifier, visitedInitializer, expression, updatedBody);
+            }
+        }
+        return factory.updateForInOrOfStatement(node, node.awaitModifier, this.discarded.visitNode(initializer), this.visitNode(node.expression), this.topLevelNested.visitIterationBody(node.statement));
+    }
+    // Expressions
+    visitBinaryExpression(node, discarded) {
+        if (isDestructuringAssignment(node))
+            return this.visitDestructuringAssignment(node, discarded);
+        if (isAssignmentExpression(node, false))
+            return this.visitAssignmentExpression(node);
+        if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */)
+            return this.factory.updateBinaryExpression(node, undefined, this.discarded.visitNode(node.left), undefined, node.operatorToken, (discarded ? this.discarded.visitNode(node.right) : this.visitNode(node.right)));
+        return this.visitEachChild(node);
+    }
+    /** Assigning an exported name also assigns each of its exports. */
+    visitAssignmentExpression(node) {
+        const left = node.left;
+        if (left instanceof Identifier && this.isSubstitutableName(left)) {
+            const exportedNames = this.getExports(left);
+            if (exportedNames !== undefined && exportedNames.length > 0) {
+                let expression = this.visitEachChild(node);
+                for (let i = 0; i < exportedNames.length; i++)
+                    expression = this.createExportExpression(exportedNames[i], expression, node, false);
+                return expression;
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    /** Not generated (except file-level reserved names) and not a local name. */
+    isSubstitutableName(name) {
+        const context = this.context;
+        return ((!context.hasAutoGenerateInfo(name) || this.isFileLevelReservedGeneratedIdentifier(name)) &&
+            (context.getEmitFlags(name) & 4096 /* EmitFlags.LocalName */) === 0);
+    }
+    visitDestructuringAssignment(node, discarded) {
+        if (this.destructuringNeedsFlattening(node.left))
+            return flattenDestructuringAssignment(this, node, !discarded, this.exportAssignments);
+        return this.visitEachChild(node);
+    }
+    /** Whether a destructuring target assigns an exported name that native destructuring can't update. */
+    destructuringNeedsFlattening(node) {
+        if (node instanceof ObjectLiteralExpression) {
+            const properties = node.properties.nodes;
+            for (let i = 0; i < properties.length; i++) {
+                const element = properties[i];
+                if (element instanceof PropertyAssignment) {
+                    if (this.destructuringNeedsFlattening(element.initializer))
+                        return true;
+                }
+                else if (element instanceof ShorthandPropertyAssignment) {
+                    if (this.destructuringNeedsFlattening(element.name))
+                        return true;
+                }
+                else if (element instanceof SpreadAssignment) {
+                    if (this.destructuringNeedsFlattening(element.expression))
+                        return true;
+                }
+                else if (element.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+                    element.kind === 178 /* SyntaxKind.GetAccessor */ ||
+                    element.kind === 179 /* SyntaxKind.SetAccessor */)
+                    return false;
+            }
+            return false;
+        }
+        if (node instanceof ArrayLiteralExpression) {
+            const elements = node.elements.nodes;
+            for (let i = 0; i < elements.length; i++) {
+                const element = elements[i];
+                const target = element instanceof SpreadElement ? element.expression : element;
+                if (this.destructuringNeedsFlattening(target))
+                    return true;
+            }
+            return false;
+        }
+        if (node instanceof Identifier) {
+            const exportedNames = this.getExports(node);
+            const count = exportedNames === undefined ? 0 : exportedNames.length;
+            if ((this.context.getEmitFlags(node) & 2048 /* EmitFlags.ExportName */) !== 0)
+                return count > 1;
+            if (count === 0)
+                return false;
+            // A single direct export of the same name becomes `exports.x` natively.
+            if (count === 1 &&
+                this.isDirectExport(node) &&
+                moduleExportNameText(exportedNames[0]) === node.text)
+                return false;
+            return true;
+        }
+        return false;
+    }
+    /** The assignment of a flattened destructuring target, assigning its exports too. */
+    createAllExportExpressions(name, value, pos, end) {
+        const factory = this.factory;
+        const exportedNames = this.getExports(name);
+        if (exportedNames !== undefined && exportedNames.length > 0) {
+            let expression = this.isDirectExport(name)
+                ? this.createDirectExportAssignment(name, value)
+                : factory.createAssignment(name, value);
+            for (let i = 0; i < exportedNames.length; i++) {
+                expression = this.createExportExpression(exportedNames[i], expression, undefined, false);
+                this.context.setCommentRange(expression, pos, end);
+            }
+            return expression;
+        }
+        if (this.isDirectExport(name))
+            return this.createDirectExportAssignment(name, value);
+        return factory.createAssignment(name, value);
+    }
+    /** `exports.x = value` for a directly exported `x`. */
+    createDirectExportAssignment(name, value) {
+        const factory = this.factory;
+        const context = this.context;
+        const exportName = factory.cloneIdentifier(name);
+        context.addEmitFlags(exportName, 384 /* EmitFlags.NoComments */ | 12 /* EmitFlags.NoSourceMap */);
+        const access = factory.createPropertyAccessExpression(factory.createIdentifier('exports'), exportName);
+        context.addEmitFlags(access, 384 /* EmitFlags.NoComments */);
+        const assignment = factory.createAssignment(access, value);
+        context.assignCommentAndSourceMapRanges(assignment, name);
+        return assignment;
+    }
+    /** Whether `name` refers to a declaration exported by the module itself, like `export let x`. */
+    isDirectExport(name) {
+        const location = this.context.mostOriginal(name);
+        if (!(location instanceof Identifier) || (location.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+            return false;
+        return this.resolver.getReferencedExportContainer(location, false) instanceof SourceFile;
+    }
+    visitPrefixUnaryExpression(node) {
+        const operand = node.operand;
+        if ((node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) &&
+            operand instanceof Identifier &&
+            (this.context.getEmitFlags(operand) & 4096 /* EmitFlags.LocalName */) === 0) {
+            const exportedNames = this.getExports(operand);
+            if (exportedNames !== undefined && exportedNames.length > 0) {
+                // exports.x = ++x;
+                let expression = this.factory.updatePrefixUnaryExpression(node, node.operator, this.visitNode(operand));
+                for (let i = 0; i < exportedNames.length; i++) {
+                    expression = this.createExportExpression(exportedNames[i], expression, undefined, false);
+                    this.context.assignCommentAndSourceMapRanges(expression, node);
+                }
+                return expression;
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    visitPostfixUnaryExpression(node, discarded) {
+        const operand = node.operand;
+        if ((node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) &&
+            operand instanceof Identifier &&
+            (this.context.getEmitFlags(operand) & 4096 /* EmitFlags.LocalName */) === 0) {
+            const exportedNames = this.getExports(operand);
+            if (exportedNames !== undefined && exportedNames.length > 0) {
+                // exports.x = (x++, x);  or, when the value is used:  (exports.x = (_a = x++, x), _a)
+                const factory = this.factory;
+                const context = this.context;
+                let temp = undefined;
+                let expression = factory.updatePostfixUnaryExpression(node, this.visitNode(operand), node.operator);
+                if (!discarded) {
+                    temp = factory.createTempVariable(0);
+                    context.addVariableDeclaration(temp);
+                    expression = factory.createAssignment(temp, expression);
+                    context.assignCommentAndSourceMapRanges(expression, node);
+                }
+                expression = factory.createCommaExpression(expression, factory.cloneIdentifier(operand));
+                context.assignCommentAndSourceMapRanges(expression, node);
+                for (let i = 0; i < exportedNames.length; i++) {
+                    expression = this.createExportExpression(exportedNames[i], expression, undefined, false);
+                    context.assignCommentAndSourceMapRanges(expression, node);
+                }
+                if (temp !== undefined) {
+                    expression = factory.createCommaExpression(expression, temp);
+                    context.assignCommentAndSourceMapRanges(expression, node);
+                }
+                return expression;
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    /** `(0, mod_1.f)()` for a call of an import; `import()` becomes a `require` call. */
+    visitCallExpression(node) {
+        const rewrite = this.options.rewriteRelativeImportExtensions === true &&
+            ((isImportCall(node) && node.arguments.nodes.length > 0) || (isInJSFile(node) && isRequireCall(node, false)));
+        if (isImportCall(node) && this.shouldTransformImportCall())
+            return this.visitImportCallExpression(node, rewrite);
+        if (rewrite)
+            return this.rewriteImportOrRequireCall(node);
+        const callee = node.expression;
+        if (callee instanceof Identifier) {
+            const expression = this.visitExpressionIdentifier(callee);
+            const updated = this.factory.updateCallExpression(node, expression, node.questionDotToken, undefined, this.visitNodes(node.arguments), node.flags);
+            if (!(expression instanceof Identifier) && (this.context.getEmitFlags(callee) & 1024 /* EmitFlags.HelperName */) === 0)
+                this.context.addEmitFlags(updated, 1048576 /* EmitFlags.IndirectCall */);
+            return updated;
+        }
+        return this.visitEachChild(node);
+    }
+    shouldTransformImportCall() {
+        const kind = this.moduleKind;
+        if ((kind >= ModuleKind.Node16 && kind <= ModuleKind.NodeNext) || kind === ModuleKind.Preserve)
+            return false;
+        return this.formats.getEmitModuleFormat(this.currentSourceFile.fileName) < ModuleKind.ES2015;
+    }
+    visitImportCallExpression(node, rewrite) {
+        if (this.moduleKind === ModuleKind.None && this.languageVersion >= ScriptTarget.ES2020)
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        const specifier = getExternalModuleName(node);
+        const moduleName = specifier instanceof StringLiteral ? factory.createStringLiteral(specifier.text, 0 /* TokenFlags.None */) : undefined;
+        const args = node.arguments.nodes;
+        const first = args.length > 0 ? this.visitNode(args[0]) : undefined;
+        // The module name only where it differs from the argument, which keeps the argument's quotes.
+        let argument;
+        if (moduleName !== undefined && (!(first instanceof StringLiteral) || first.text !== moduleName.text))
+            argument = moduleName;
+        else if (first !== undefined && rewrite)
+            argument =
+                first instanceof StringLiteral
+                    ? rewriteModuleSpecifier(this.context, first, this.options)
+                    : factory.createRewriteRelativeImportExtensionsHelper(first, this.options.jsx === JsxEmit.Preserve);
+        else
+            argument = first;
+        return this.createImportCallExpressionCommonJS(argument);
+    }
+    /** `Promise.resolve().then(() => __importStar(require(x)))` */
+    createImportCallExpressionCommonJS(argument) {
+        const factory = this.factory;
+        // A non-literal argument is converted to a string synchronously, as `import()` does.
+        const needSyncEval = argument !== undefined && !isSimpleInlineableExpression(argument);
+        const resolveArguments = [];
+        if (needSyncEval)
+            resolveArguments.push(factory.created(new TemplateExpression(factory.created(new TemplateHead('', '', 0 /* TokenFlags.None */)), factory.createNodeList([
+                factory.created(new TemplateSpan(argument, factory.created(new TemplateTail('', '', 0 /* TokenFlags.None */)))),
+            ]))));
+        const promiseResolve = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Promise'), factory.createIdentifier('resolve')), resolveArguments);
+        const requireArguments = needSyncEval
+            ? [factory.createIdentifier('s')]
+            : argument !== undefined
+                ? [argument]
+                : [];
+        const requireCall = factory.createImportStarHelper(factory.createCallExpression(factory.createIdentifier('require'), requireArguments));
+        const parameters = needSyncEval ? [factory.createParameter(factory.createIdentifier('s'))] : [];
+        return factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolve, factory.createIdentifier('then')), [factory.createArrowFunction(parameters, requireCall)]);
+    }
+    rewriteImportOrRequireCall(node) {
+        const factory = this.factory;
+        const expression = this.visitNode(node.expression);
+        let args = node.arguments;
+        const nodes = args.nodes;
+        if (nodes.length > 0) {
+            const first = nodes[0];
+            const rewritten = first instanceof StringLiteral || first.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */
+                ? rewriteModuleSpecifier(this.context, first, this.options)
+                : factory.createRewriteRelativeImportExtensionsHelper(first, this.options.jsx === JsxEmit.Preserve);
+            const rest = nodes.slice(1);
+            const visitedRest = this.visitArray(rest);
+            if (rewritten !== first || visitedRest !== rest)
+                args = new NodeList(args.pos, args.end, [rewritten].concat(visitedRest));
+        }
+        return factory.updateCallExpression(node, expression, node.questionDotToken, undefined, args, node.flags);
+    }
+    visitTaggedTemplateExpression(node) {
+        const tag = node.tag;
+        if (!(tag instanceof Identifier))
+            return this.visitEachChild(node);
+        const expression = this.visitExpressionIdentifier(tag);
+        const updated = this.factory.updateTaggedTemplateExpression(node, expression, undefined, undefined, this.visitNode(node.template), node.flags);
+        if (!(expression instanceof Identifier) && (this.context.getEmitFlags(tag) & 1024 /* EmitFlags.HelperName */) === 0)
+            this.context.addEmitFlags(updated, 1048576 /* EmitFlags.IndirectCall */);
+        return updated;
+    }
+    visitShorthandPropertyAssignment(node) {
+        const factory = this.factory;
+        const name = node.name;
+        const reference = name instanceof Identifier ? this.visitExpressionIdentifier(name) : name;
+        if (reference !== name) {
+            // `{ x }` becomes `{ x: exports.x }`; with an initializer, it's part of a destructuring assignment.
+            let expression = reference;
+            if (node.objectAssignmentInitializer !== undefined)
+                expression = factory.createAssignment(expression, this.visitNode(node.objectAssignmentInitializer));
+            const assignment = factory.createPropertyAssignment(name, expression);
+            assignment.pos = node.pos;
+            assignment.end = node.end;
+            this.context.assignCommentAndSourceMapRanges(assignment, node);
+            return assignment;
+        }
+        return factory.updateShorthandPropertyAssignment(node, undefined, reference, undefined, undefined, node.equalsToken, this.visitNode(node.objectAssignmentInitializer));
+    }
+    /** `exports.x` for an exported name, `mod_1.x` or `mod_1.default` for an import. */
+    visitExpressionIdentifier(node) {
+        const context = this.context;
+        const factory = this.factory;
+        const info = context.getAutoGenerateInfo(node);
+        if ((info !== undefined && (info.flags & 64 /* GeneratedIdentifierFlags.AllowNameSubstitution */) === 0) ||
+            (context.getEmitFlags(node) & (1024 /* EmitFlags.HelperName */ | 4096 /* EmitFlags.LocalName */)) !== 0 ||
+            isDeclarationNameOfEnumOrNamespace(context.mostOriginal(node)))
+            return node;
+        const location = context.mostOriginal(node);
+        if (!(location instanceof Identifier))
+            return node;
+        // Generated names, such as the JSX transform's `_jsx`, may still refer to an import.
+        const synthesized = (location.flags & 16 /* NodeFlags.Synthesized */) !== 0;
+        const container = synthesized
+            ? undefined
+            : this.resolver.getReferencedExportContainer(location, (context.getEmitFlags(node) & 2048 /* EmitFlags.ExportName */) !== 0);
+        if (container instanceof SourceFile) {
+            const reference = factory.createPropertyAccessExpression(factory.createIdentifier('exports'), factory.cloneIdentifier(node));
+            context.assignCommentAndSourceMapRanges(reference, node);
+            reference.pos = node.pos;
+            reference.end = node.end;
+            return reference;
+        }
+        const declaration = this.resolver.getReferencedImportDeclaration(location);
+        if (declaration instanceof ImportClause && declaration.parent !== undefined) {
+            const reference = factory.createPropertyAccessExpression(factory.createGeneratedNameForNode(declaration.parent, 0, '', ''), factory.createIdentifier('default'));
+            context.assignCommentAndSourceMapRanges(reference, node);
+            reference.pos = node.pos;
+            reference.end = node.end;
+            return reference;
+        }
+        if (declaration instanceof ImportSpecifier) {
+            const imported = declaration.propertyName !== undefined ? declaration.propertyName : declaration.name;
+            const importDeclaration = findImportDeclaration(declaration);
+            const target = factory.createGeneratedNameForNode(importDeclaration !== undefined ? importDeclaration : declaration, 0, '', '');
+            let reference;
+            if (imported instanceof StringLiteral)
+                reference = factory.createElementAccessExpression(target, factory.createStringLiteralFromNode(imported));
+            else {
+                const name = imported instanceof Identifier ? factory.cloneIdentifier(imported) : imported;
+                context.addEmitFlags(name, 12 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoComments */);
+                reference = factory.createPropertyAccessExpression(target, name);
+            }
+            context.assignCommentAndSourceMapRanges(reference, node);
+            reference.pos = node.pos;
+            reference.end = node.end;
+            return reference;
+        }
+        return node;
+    }
+    /** The export names of what `name` refers to. */
+    getExports(name) {
+        const context = this.context;
+        const info = this.moduleInfo();
+        if (!context.hasAutoGenerateInfo(name)) {
+            const location = context.mostOriginal(name);
+            if (!(location instanceof Identifier) || (location.flags & 16 /* NodeFlags.Synthesized */) !== 0)
+                return undefined;
+            const importDeclaration = this.resolver.getReferencedImportDeclaration(location);
+            if (importDeclaration !== undefined)
+                return info.getExportedBindings(importDeclaration);
+            // An exported namespace or enum may merge with ambient declarations, so all value declarations count.
+            const declarations = this.resolver.getReferencedValueDeclarations(location);
+            if (declarations === undefined)
+                return undefined;
+            const bindings = [];
+            for (let i = 0; i < declarations.length; i++) {
+                const exported = info.getExportedBindings(declarations[i]);
+                if (exported === undefined)
+                    continue;
+                for (let j = 0; j < exported.length; j++)
+                    if (bindings.indexOf(exported[j]) < 0)
+                        bindings.push(exported[j]);
+            }
+            return bindings;
+        }
+        if (this.isFileLevelReservedGeneratedIdentifier(name)) {
+            const specifiers = info.exportSpecifiers.get(name.text);
+            if (specifiers === undefined)
+                return undefined;
+            const names = [];
+            for (let i = 0; i < specifiers.length; i++)
+                names.push(specifiers[i].name);
+            return names;
+        }
+        return undefined;
+    }
+    isFileLevelReservedGeneratedIdentifier(name) {
+        const info = this.context.getAutoGenerateInfo(name);
+        const flags = 32 /* GeneratedIdentifierFlags.FileLevel */ |
+            16 /* GeneratedIdentifierFlags.Optimistic */ |
+            8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */;
+        return info !== undefined && (info.flags & flags) === flags;
+    }
+}
+/** Builds the statements of an exported variable statement, grouping declarations and assignments. */
+class ExportedVariableSplitter {
+    owner;
+    node;
+    statements;
+    variables;
+    expressions;
+    modifiers;
+    hasModifiers;
+    constructor(owner, node) {
+        this.owner = owner;
+        this.node = node;
+        this.statements = [];
+        this.variables = [];
+        this.expressions = [];
+        this.modifiers = undefined;
+        this.hasModifiers = false;
+    }
+    ensureModifiers() {
+        if (!this.hasModifiers) {
+            this.modifiers = this.owner.extractModifiers(this.node.modifiers, ~exportDefault);
+            this.hasModifiers = true;
+        }
+        return true;
+    }
+    pushVariable(variable) {
+        this.commitExpressions();
+        this.variables.push(variable);
+        return true;
+    }
+    pushExpression(expression) {
+        this.commitVariables();
+        this.expressions.push(expression);
+        return true;
+    }
+    commitVariables() {
+        if (this.variables.length === 0)
+            return false;
+        const factory = this.owner.factory;
+        const list = this.node.declarationList;
+        const statement = factory.updateVariableStatement(this.node, this.modifiers, factory.updateVariableDeclarationList(list, factory.createNodeList(this.variables), list.flags));
+        if (this.statements.length > 0)
+            this.owner.context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+        this.statements.push(statement);
+        this.variables = [];
+        return true;
+    }
+    commitExpressions() {
+        if (this.expressions.length === 0)
+            return false;
+        const factory = this.owner.factory;
+        const statement = factory.createExpressionStatement(factory.inlineExpressions(this.expressions));
+        this.owner.context.assignCommentAndSourceMapRanges(statement, this.node);
+        if (this.statements.length > 0)
+            this.owner.context.addEmitFlags(statement, 384 /* EmitFlags.NoComments */);
+        this.statements.push(statement);
+        this.expressions = [];
+        return true;
+    }
+}
+function appendAll(target, source) {
+    for (let i = 0; i < source.length; i++)
+        target.push(source[i]);
+    return target;
+}
+function standardPrologueEnd(statements) {
+    let i = 0;
+    while (i < statements.length && isPrologueDirective(statements[i]))
+        i++;
+    return i;
+}
+function bindingElementsOf(node) {
+    const elements = getElements(node);
+    return elements === undefined ? [] : elements.nodes;
+}
+function bindingNameOf(node) {
+    return getName(node);
+}
+function declarationNameOf(node) {
+    return getName(node);
+}
+function namespaceNameOf(node) {
+    return getName(node);
+}
+function findImportDeclaration(node) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (current instanceof ImportDeclaration)
+            return current;
+    return undefined;
+}
+function isDeclarationNameOfEnumOrNamespace(original) {
+    const parent = original.parent;
+    if (parent === undefined)
+        return false;
+    if (parent.kind !== 267 /* SyntaxKind.EnumDeclaration */ && parent.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+        return false;
+    return getName(parent) === original;
+}
+/** A literal or keyword: copied into several places without side effects. */
+function isSimpleInlineableExpression(node) {
+    return !(node instanceof Identifier) && isSimpleCopiableExpression(node);
+}
+/** Whether a file has `import()` calls. */
+function containsDynamicImport(file) {
+    const finder = new DynamicImportFinder();
+    return file.forEachChild(finder);
+}
+class DynamicImportFinder extends NodeVisitor {
+    visitNode(node) {
+        // `import()`, not `import.defer()`.
+        if (node instanceof CallExpression && node.expression.kind === 101 /* SyntaxKind.ImportKeyword */)
+            return true;
+        return node.forEachChild(this);
+    }
+}