interface AsynchronousDependencies {

aliasedModuleNames: Expression[];

unaliasedModuleNames: Expression[];

importAliasNames: ParameterDeclaration[];

}

function getTransformModuleDelegate(moduleKind: ModuleKind): (node: SourceFile) => SourceFile {

switch (moduleKind) {

case ModuleKind.AMD: return transformAMDModule;

case ModuleKind.UMD: return transformUMDModule;

default: return transformCommonJSModule;

}

}

const {

startLexicalEnvironment,

endLexicalEnvironment

} = context;

const compilerOptions = context.getCompilerOptions();

const resolver = context.getEmitResolver();

const host = context.getEmitHost();

const languageVersion = getEmitScriptTarget(compilerOptions);

const moduleKind = getEmitModuleKind(compilerOptions);

const previousOnSubstituteNode = context.onSubstituteNode;

const previousOnEmitNode = context.onEmitNode;

context.onSubstituteNode = onSubstituteNode;

context.onEmitNode = onEmitNode;

context.enableSubstitution(SyntaxKind.Identifier); // Substitutes expression identifiers with imported/exported symbols.

context.enableSubstitution(SyntaxKind.BinaryExpression); // Substitutes assignments to exported symbols.

context.enableSubstitution(SyntaxKind.PrefixUnaryExpression); // Substitutes updates to exported symbols.

context.enableSubstitution(SyntaxKind.PostfixUnaryExpression); // Substitutes updates to exported symbols.

context.enableSubstitution(SyntaxKind.ShorthandPropertyAssignment); // Substitutes shorthand property assignments for imported/exported symbols.

context.enableEmitNotification(SyntaxKind.SourceFile); // Restore state when substituting nodes in a file.

const moduleInfoMap: ExternalModuleInfo[] = []; // The ExternalModuleInfo for each file.

const deferredExports: Statement[][] = []; // Exports to defer until an EndOfDeclarationMarker is found.

let currentSourceFile: SourceFile; // The current file.

let currentModuleInfo: ExternalModuleInfo; // The ExternalModuleInfo for the current file.

let noSubstitution: boolean[]; // Set of nodes for which substitution rules should be ignored.

let needUMDDynamicImportHelper: boolean;

return transformSourceFile;

/**

function transformSourceFile(node: SourceFile) {

if (node.isDeclarationFile || !(isExternalModule(node) || compilerOptions.isolatedModules || node.transformFlags & TransformFlags.ContainsDynamicImport)) {

return node;

}

currentSourceFile = node;

currentModuleInfo = collectExternalModuleInfo(node, resolver, compilerOptions);

moduleInfoMap[getOriginalNodeId(node)] = currentModuleInfo;

// Perform the transformation.

const transformModule = getTransformModuleDelegate(moduleKind);

const updated = transformModule(node);

currentSourceFile = undefined;

currentModuleInfo = undefined;

needUMDDynamicImportHelper = false;

return aggregateTransformFlags(updated);

}

function shouldEmitUnderscoreUnderscoreESModule() {

if (!currentModuleInfo.exportEquals && isExternalModule(currentSourceFile)) {

return true;

}

return false;

}

/**

function transformCommonJSModule(node: SourceFile) {

startLexicalEnvironment();

const statements: Statement[] = [];

const ensureUseStrict = compilerOptions.alwaysStrict || (!compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile));

const statementOffset = addPrologue(statements, node.statements, ensureUseStrict, sourceElementVisitor);

if (shouldEmitUnderscoreUnderscoreESModule()) {

append(statements, createUnderscoreUnderscoreESModule());

}

append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement));

addRange(statements, visitNodes(node.statements, sourceElementVisitor, isStatement, statementOffset));

addExportEqualsIfNeeded(statements, /*emitAsReturn*/ false);

addRange(statements, endLexicalEnvironment());

const updated = updateSourceFileNode(node, setTextRange(createNodeArray(statements), node.statements));

if (currentModuleInfo.hasExportStarsToExportValues && !compilerOptions.importHelpers) {

// If we have any `export * from ...` declarations

// we need to inform the emitter to add the __export helper.

addEmitHelper(updated, exportStarHelper);

}

addEmitHelpers(updated, context.readEmitHelpers());

return updated;

}

/**

function transformAMDModule(node: SourceFile) {

const define = createIdentifier("define");

const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);

// An AMD define function has the following shape:

//

// define(id?, dependencies?, factory);

//

// This has the shape of the following:

//

// define(name, ["module1", "module2"], function (module1Alias) { ... }

//

// The location of the alias in the parameter list in the factory function needs to

// match the position of the module name in the dependency list.

//

// To ensure this is true in cases of modules with no aliases, e.g.:

//

// import "module"

//

// or

//

// /// <amd-dependency path= "a.css" />

//

// we need to add modules without alias names to the end of the dependencies list

const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ true);

// Create an updated SourceFile:

//

// define(moduleName?, ["module1", "module2"], function ...

return updateSourceFileNode(node,

setTextRange(

createNodeArray([

createStatement(

createCall(

define,

/*typeArguments*/ undefined,

[

// Add the module name (if provided).

...(moduleName ? [moduleName] : []),

// Add the dependency array argument:

//

// ["require", "exports", module1", "module2", ...]

createArrayLiteral([

createLiteral("require"),

createLiteral("exports"),

...aliasedModuleNames,

...unaliasedModuleNames

]),

// Add the module body function argument:

//

// function (require, exports, module1, module2) ...

createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

[

createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),

createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),

...importAliasNames

],

/*type*/ undefined,

transformAsynchronousModuleBody(node)

)

]

)

)

]),

/*location*/ node.statements

)

);

}

/**

function transformUMDModule(node: SourceFile) {

const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ false);

const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);

const umdHeader = createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

[createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "factory")],

/*type*/ undefined,

setTextRange(

createBlock(

[

createIf(

createLogicalAnd(

createTypeCheck(createIdentifier("module"), "object"),

createTypeCheck(createPropertyAccess(createIdentifier("module"), "exports"), "object")

),

createBlock([

createVariableStatement(

/*modifiers*/ undefined,

[

createVariableDeclaration(

"v",

/*type*/ undefined,

createCall(

createIdentifier("factory"),

/*typeArguments*/ undefined,

[

createIdentifier("require"),

createIdentifier("exports")

]

)

)

]

),

setEmitFlags(

createIf(

createStrictInequality(

createIdentifier("v"),

createIdentifier("undefined")

),

createStatement(

createAssignment(

createPropertyAccess(createIdentifier("module"), "exports"),

createIdentifier("v")

)

)

),

EmitFlags.SingleLine

)

]),

createIf(

createLogicalAnd(

createTypeCheck(createIdentifier("define"), "function"),

createPropertyAccess(createIdentifier("define"), "amd")

),

createBlock([

createStatement(

createCall(

createIdentifier("define"),

/*typeArguments*/ undefined,

[

// Add the module name (if provided).

...(moduleName ? [moduleName] : []),

createArrayLiteral([

createLiteral("require"),

createLiteral("exports"),

...aliasedModuleNames,

...unaliasedModuleNames

]),

createIdentifier("factory")

]

)

)

])

)

)

],

/*multiLine*/ true

),

/*location*/ undefined

)

);

// Create an updated SourceFile:

//

// (function (factory) {

// if (typeof module === "object" && typeof module.exports === "object") {

// var v = factory(require, exports);

// if (v !== undefined) module.exports = v;

// }

// else if (typeof define === 'function' && define.amd) {

// define(["require", "exports"], factory);

// }

// })(function ...)

return updateSourceFileNode(

node,

setTextRange(

createNodeArray([

createStatement(

createCall(

umdHeader,

/*typeArguments*/ undefined,

[

// Add the module body function argument:

//

// function (require, exports) ...

createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

[

createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),

createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),

...importAliasNames

],

/*type*/ undefined,

transformAsynchronousModuleBody(node)

)

]

)

)

]),

/*location*/ node.statements

)

);

}

/**

function collectAsynchronousDependencies(node: SourceFile, includeNonAmdDependencies: boolean): AsynchronousDependencies {

// names of modules with corresponding parameter in the factory function

const aliasedModuleNames: Expression[] = [];

// names of modules with no corresponding parameters in factory function

const unaliasedModuleNames: Expression[] = [];

// names of the parameters in the factory function; these

// parameters need to match the indexes of the corresponding

// module names in aliasedModuleNames.

const importAliasNames: ParameterDeclaration[] = [];

// Fill in amd-dependency tags

for (const amdDependency of node.amdDependencies) {

if (amdDependency.name) {

aliasedModuleNames.push(createLiteral(amdDependency.path));

importAliasNames.push(createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, amdDependency.name));

}

else {

unaliasedModuleNames.push(createLiteral(amdDependency.path));

}

}

for (const importNode of currentModuleInfo.externalImports) {

// Find the name of the external module

const externalModuleName = getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions);

// Find the name of the module alias, if there is one

const importAliasName = getLocalNameForExternalImport(importNode, currentSourceFile);

// It is possible that externalModuleName is undefined if it is not string literal.

// This can happen in the invalid import syntax.

// E.g : "import * from alias from 'someLib';"

if (externalModuleName) {

if (includeNonAmdDependencies && importAliasName) {

// Set emitFlags on the name of the classDeclaration

// This is so that when printer will not substitute the identifier

setEmitFlags(importAliasName, EmitFlags.NoSubstitution);

aliasedModuleNames.push(externalModuleName);

importAliasNames.push(createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, importAliasName));

}

else {

unaliasedModuleNames.push(externalModuleName);

}

}

}

return { aliasedModuleNames, unaliasedModuleNames, importAliasNames };

}

/**

function transformAsynchronousModuleBody(node: SourceFile) {

startLexicalEnvironment();

const statements: Statement[] = [];

const statementOffset = addPrologue(statements, node.statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, sourceElementVisitor);

if (shouldEmitUnderscoreUnderscoreESModule()) {

append(statements, createUnderscoreUnderscoreESModule());

}

// Visit each statement of the module body.

append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, sourceElementVisitor, isStatement));

addRange(statements, visitNodes(node.statements, sourceElementVisitor, isStatement, statementOffset));

// Append the 'export =' statement if provided.

addExportEqualsIfNeeded(statements, /*emitAsReturn*/ true);

// End the lexical environment for the module body

// and merge any new lexical declarations.

addRange(statements, endLexicalEnvironment());

const body = createBlock(statements, /*multiLine*/ true);

if (currentModuleInfo.hasExportStarsToExportValues && !compilerOptions.importHelpers) {

// If we have any `export * from ...` declarations

// we need to inform the emitter to add the __export helper.

addEmitHelper(body, exportStarHelper);

}

if (needUMDDynamicImportHelper) {

addEmitHelper(body, dynamicImportUMDHelper);

}

return body;

}

/**

function addExportEqualsIfNeeded(statements: Statement[], emitAsReturn: boolean) {

if (currentModuleInfo.exportEquals) {

const expressionResult = visitNode(currentModuleInfo.exportEquals.expression, importCallExpressionVisitor);

if (expressionResult) {

if (emitAsReturn) {

const statement = createReturn(expressionResult);

setTextRange(statement, currentModuleInfo.exportEquals);

setEmitFlags(statement, EmitFlags.NoTokenSourceMaps | EmitFlags.NoComments);

statements.push(statement);

}

else {

const statement = createStatement(

createAssignment(

createPropertyAccess(

createIdentifier("module"),

"exports"

),

expressionResult

)

);

setTextRange(statement, currentModuleInfo.exportEquals);

setEmitFlags(statement, EmitFlags.NoComments);

statements.push(statement);

}

}

}

}

//

// Top-Level Source Element Visitors

//

/**

function sourceElementVisitor(node: Node): VisitResult<Node> {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

return visitImportDeclaration(<ImportDeclaration>node);

case SyntaxKind.ImportEqualsDeclaration:

return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);

case SyntaxKind.ExportDeclaration:

return visitExportDeclaration(<ExportDeclaration>node);

case SyntaxKind.ExportAssignment:

return visitExportAssignment(<ExportAssignment>node);

case SyntaxKind.VariableStatement:

return visitVariableStatement(<VariableStatement>node);

case SyntaxKind.FunctionDeclaration:

return visitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.ClassDeclaration:

return visitClassDeclaration(<ClassDeclaration>node);

case SyntaxKind.MergeDeclarationMarker:

return visitMergeDeclarationMarker(<MergeDeclarationMarker>node);

case SyntaxKind.EndOfDeclarationMarker:

return visitEndOfDeclarationMarker(<EndOfDeclarationMarker>node);

default:

return visitEachChild(node, importCallExpressionVisitor, context);

}

}

function importCallExpressionVisitor(node: Expression): VisitResult<Expression> {

// This visitor does not need to descend into the tree if there is no dynamic import,

// as export/import statements are only transformed at the top level of a file.

if (!(node.transformFlags & TransformFlags.ContainsDynamicImport)) {

return node;

}

if (isImportCall(node)) {

return visitImportCallExpression(<ImportCall>node);

}

else {

return visitEachChild(node, importCallExpressionVisitor, context);

}

}

function visitImportCallExpression(node: ImportCall): Expression {

switch (compilerOptions.module) {

case ModuleKind.AMD:

return transformImportCallExpressionAMD(node);

case ModuleKind.UMD:

return transformImportCallExpressionUMD(node);

case ModuleKind.CommonJS:

default:

return transformImportCallExpressionCommonJS(node);

}

}

function transformImportCallExpressionUMD(node: ImportCall): Expression {

// (function (factory) {

// ... (regular UMD)

// }

// })(function (require, exports, useSyncRequire) {

// "use strict";

// Object.defineProperty(exports, "__esModule", { value: true });

// var __syncRequire = typeof module === "object" && typeof module.exports === "object";

// var __resolved = new Promise(function (resolve) { resolve(); });

// .....

// __syncRequire

// ? __resolved.then(function () { return require(x); }) /*CommonJs Require*/

// : new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/

// });

needUMDDynamicImportHelper = true;

return createConditional(

/*condition*/ createIdentifier("__syncRequire"),

/*whenTrue*/ transformImportCallExpressionCommonJS(node),

/*whenFalse*/ transformImportCallExpressionAMD(node)

);

}

function transformImportCallExpressionAMD(node: ImportCall): Expression {

// improt("./blah")

// emit as

// define(["require", "exports", "blah"], function (require, exports) {

// ...

// new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/

// });

const resolve = createUniqueName("resolve");

const reject = createUniqueName("reject");

return createNew(

createIdentifier("Promise"),

/*typeArguments*/ undefined,

[createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

[createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve),

createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject)],

/*type*/ undefined,

createBlock([createStatement(

createCall(

createIdentifier("require"),

/*typeArguments*/ undefined,

[createArrayLiteral([firstOrUndefined(node.arguments) || createOmittedExpression()]), resolve, reject]

))])

)]);

}

function transformImportCallExpressionCommonJS(node: ImportCall): Expression {

// import("./blah")

// emit as

// Promise.resolve().then(function () { return require(x); }) /*CommonJs Require*/

// We have to wrap require in then callback so that require is done in asynchronously

// if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately

return createCall(

createPropertyAccess(

createCall(createPropertyAccess(createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []),

"then"),

/*typeArguments*/ undefined,

[createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

/*parameters*/ undefined,

/*type*/ undefined,

createBlock([createReturn(createCall(createIdentifier("require"), /*typeArguments*/ undefined, node.arguments))])

)]);

}

/**

function visitImportDeclaration(node: ImportDeclaration): VisitResult<Statement> {

let statements: Statement[];

const namespaceDeclaration = getNamespaceDeclarationNode(node);

if (moduleKind !== ModuleKind.AMD) {

if (!node.importClause) {

// import "mod";

return setTextRange(createStatement(createRequireCall(node)), node);

}

else {

const variables: VariableDeclaration[] = [];

if (namespaceDeclaration && !isDefaultImport(node)) {

// import * as n from "mod";

variables.push(

createVariableDeclaration(

getSynthesizedClone(namespaceDeclaration.name),

/*type*/ undefined,

createRequireCall(node)

)

);

}

else {

// import d from "mod";

// import { x, y } from "mod";

// import d, { x, y } from "mod";

// import d, * as n from "mod";

variables.push(

createVariableDeclaration(

getGeneratedNameForNode(node),

/*type*/ undefined,

createRequireCall(node)

)

);

if (namespaceDeclaration && isDefaultImport(node)) {

variables.push(

createVariableDeclaration(

getSynthesizedClone(namespaceDeclaration.name),

/*type*/ undefined,

getGeneratedNameForNode(node)

)

);

}

}

statements = append(statements,

setTextRange(

createVariableStatement(

/*modifiers*/ undefined,

createVariableDeclarationList(

variables,

languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None

)

),

/*location*/ node

)

);

}

}

else if (namespaceDeclaration && isDefaultImport(node)) {

// import d, * as n from "mod";

statements = append(statements,

createVariableStatement(

/*modifiers*/ undefined,

createVariableDeclarationList(

[

setTextRange(

createVariableDeclaration(

getSynthesizedClone(namespaceDeclaration.name),

/*type*/ undefined,

getGeneratedNameForNode(node)

),

/*location*/ node

)

],

languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None

)

)

);

}

if (hasAssociatedEndOfDeclarationMarker(node)) {

// Defer exports until we encounter an EndOfDeclarationMarker node

const id = getOriginalNodeId(node);

deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);

}

else {

statements = appendExportsOfImportDeclaration(statements, node);

}

return singleOrMany(statements);

}

/**

function createRequireCall(importNode: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration) {

const moduleName = getExternalModuleNameLiteral(importNode, currentSourceFile, host, resolver, compilerOptions);

const args: Expression[] = [];

if (moduleName) {

args.push(moduleName);

}

return createCall(createIdentifier("require"), /*typeArguments*/ undefined, args);

}

/**

function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): VisitResult<Statement> {

Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");

let statements: Statement[];

if (moduleKind !== ModuleKind.AMD) {

if (hasModifier(node, ModifierFlags.Export)) {

statements = append(statements,

setTextRange(

createStatement(

createExportExpression(

node.name,

createRequireCall(node)

)

),

node

)

);

}

else {

statements = append(statements,

setTextRange(

createVariableStatement(

/*modifiers*/ undefined,

createVariableDeclarationList(

[

createVariableDeclaration(

getSynthesizedClone(node.name),

/*type*/ undefined,

createRequireCall(node)

)

],

/*flags*/ languageVersion >= ScriptTarget.ES2015 ? NodeFlags.Const : NodeFlags.None

)

),

node

)

);

}

}

else {

if (hasModifier(node, ModifierFlags.Export)) {

statements = append(statements,

setTextRange(

createStatement(

createExportExpression(getExportName(node), getLocalName(node))

),

node

)

);

}

}

if (hasAssociatedEndOfDeclarationMarker(node)) {

// Defer exports until we encounter an EndOfDeclarationMarker node

const id = getOriginalNodeId(node);

deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);

}

else {

statements = appendExportsOfImportEqualsDeclaration(statements, node);

}

return singleOrMany(statements);

}

/**

function visitExportDeclaration(node: ExportDeclaration): VisitResult<Statement> {

if (!node.moduleSpecifier) {

// Elide export declarations with no module specifier as they are handled

// elsewhere.

return undefined;

}

const generatedName = getGeneratedNameForNode(node);

if (node.exportClause) {

const statements: Statement[] = [];

// export { x, y } from "mod";

if (moduleKind !== ModuleKind.AMD) {

statements.push(

setTextRange(

createVariableStatement(

/*modifiers*/ undefined,

createVariableDeclarationList([

createVariableDeclaration(

generatedName,

/*type*/ undefined,

createRequireCall(node)

)

])

),

/*location*/ node

)

);

}

for (const specifier of node.exportClause.elements) {

const exportedValue = createPropertyAccess(

generatedName,

specifier.propertyName || specifier.name

);

statements.push(

setTextRange(

createStatement(

createExportExpression(getExportName(specifier), exportedValue)

),

specifier

)

);

}

return singleOrMany(statements);

}

else {

// export * from "mod";

return setTextRange(

createStatement(

createExportStarHelper(context, moduleKind !== ModuleKind.AMD ? createRequireCall(node) : generatedName)

),

node

);

}

}

/**

function visitExportAssignment(node: ExportAssignment): VisitResult<Statement> {

if (node.isExportEquals) {

return undefined;

}

let statements: Statement[];

const original = node.original;

if (original && hasAssociatedEndOfDeclarationMarker(original)) {

// Defer exports until we encounter an EndOfDeclarationMarker node

const id = getOriginalNodeId(node);

deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);

}

else {

statements = appendExportStatement(statements, createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);

}

return singleOrMany(statements);

}

/**

function visitFunctionDeclaration(node: FunctionDeclaration): VisitResult<Statement> {

let statements: Statement[];

if (hasModifier(node, ModifierFlags.Export)) {

statements = append(statements,

setOriginalNode(

setTextRange(

createFunctionDeclaration(

/*decorators*/ undefined,

visitNodes(node.modifiers, modifierVisitor, isModifier),

node.asteriskToken,

getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),

/*typeParameters*/ undefined,

visitNodes(node.parameters, importCallExpressionVisitor),

/*type*/ undefined,

visitEachChild(node.body, importCallExpressionVisitor, context)

),

/*location*/ node

),

/*original*/ node

)

);

}

else {

statements = append(statements, visitEachChild(node, importCallExpressionVisitor, context));

}

if (hasAssociatedEndOfDeclarationMarker(node)) {

// Defer exports until we encounter an EndOfDeclarationMarker node

const id = getOriginalNodeId(node);

deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);

}

else {

statements = appendExportsOfHoistedDeclaration(statements, node);

}

return singleOrMany(statements);

}

/**

function visitClassDeclaration(node: ClassDeclaration): VisitResult<Statement> {

let statements: Statement[];

if (hasModifier(node, ModifierFlags.Export)) {

statements = append(statements,

setOriginalNode(

setTextRange(

createClassDeclaration(

/*decorators*/ undefined,

visitNodes(node.modifiers, modifierVisitor, isModifier),

getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true),

/*typeParameters*/ undefined,

visitNodes(node.heritageClauses, importCallExpressionVisitor),

visitNodes(node.members, importCallExpressionVisitor)

),

node

),

node

)

);

}

else {

statements = append(statements, visitEachChild(node, importCallExpressionVisitor, context));

}

if (hasAssociatedEndOfDeclarationMarker(node)) {

// Defer exports until we encounter an EndOfDeclarationMarker node

const id = getOriginalNodeId(node);

deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);

}

else {

statements = appendExportsOfHoistedDeclaration(statements, node);

}

return singleOrMany(statements);

}

/**

function visitVariableStatement(node: VariableStatement): VisitResult<Statement> {

let statements: Statement[];

let variables: VariableDeclaration[];

let expressions: Expression[];

if (hasModifier(node, ModifierFlags.Export)) {

let modifiers: NodeArray<Modifier>;

// If we're exporting these variables, then these just become assignments to 'exports.x'.

// We only want to emit assignments for variables with initializers.

for (const variable of node.declarationList.declarations) {

if (isIdentifier(variable.name) && isLocalName(variable.name)) {

if (!modifiers) {

modifiers = visitNodes(node.modifiers, modifierVisitor, isModifier);

}

variables = append(variables, variable);

}

else if (variable.initializer) {

expressions = append(expressions, transformInitializedVariable(variable));

}

}

if (variables) {