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 {

factory,

getEmitHelperFactory: emitHelpers,

startLexicalEnvironment,

endLexicalEnvironment,

hoistVariableDeclaration

} = 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.CallExpression); // Substitute calls to imported/exported symbols to avoid incorrect `this`.

context.enableSubstitution(SyntaxKind.TaggedTemplateExpression); // Substitute calls to imported/exported symbols to avoid incorrect `this`.

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

context.enableSubstitution(SyntaxKind.BinaryExpression); // Substitutes assignments 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[] | undefined)[] = []; // Exports to defer until an EndOfDeclarationMarker is found.

let currentSourceFile: SourceFile; // The current file.

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

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

let needUMDDynamicImportHelper: boolean;

return chainBundle(context, transformSourceFile);

/**

function transformSourceFile(node: SourceFile) {

if (node.isDeclarationFile ||

!(isEffectiveExternalModule(node, compilerOptions) ||

node.transformFlags & TransformFlags.ContainsDynamicImport ||

(isJsonSourceFile(node) && hasJsonModuleEmitEnabled(compilerOptions) && outFile(compilerOptions)))) {

return node;

}

currentSourceFile = node;

currentModuleInfo = collectExternalModuleInfo(context, 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 updated;

}

function shouldEmitUnderscoreUnderscoreESModule() {

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

return true;

}

return false;

}

/**

function transformCommonJSModule(node: SourceFile) {

startLexicalEnvironment();

const statements: Statement[] = [];

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

const statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict && !isJsonSourceFile(node), topLevelVisitor);

if (shouldEmitUnderscoreUnderscoreESModule()) {

append(statements, createUnderscoreUnderscoreESModule());

}

if (length(currentModuleInfo.exportedNames)) {

const chunkSize = 50;

for (let i=0; i<currentModuleInfo.exportedNames!.length; i += chunkSize) {

append(

statements,

factory.createExpressionStatement(

reduceLeft(

currentModuleInfo.exportedNames!.slice(i, i + chunkSize),

(prev, nextId) => factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(idText(nextId))), prev),

factory.createVoidZero() as Expression

)

)

);

}

}

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

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

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

insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());

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

addEmitHelpers(updated, context.readEmitHelpers());

return updated;

}

/**

function transformAMDModule(node: SourceFile) {

const define = factory.createIdentifier("define");

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

const jsonSourceFile = isJsonSourceFile(node) && node;

// 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(mofactory.updateSourceFile", "module2"], function ...

const updated = factory.updateSourceFile(node,

setTextRange(

factory.createNodeArray([

factory.createExpressionStatement(

factory.createCallExpression(

define,

/*typeArguments*/ undefined,

[

// Add the module name (if provided).

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

// Add the dependency array argument:

//

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

factory.createArrayLiteralExpression(jsonSourceFile ? emptyArray : [

factory.createStringLiteral("require"),

factory.createStringLiteral("exports"),

...aliasedModuleNames,

...unaliasedModuleNames

]),

// Add the module body function argument:

//

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

jsonSourceFile ?

jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory.createObjectLiteralExpression() :

factory.createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

[

factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),

factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),

...importAliasNames

],

/*type*/ undefined,

transformAsynchronousModuleBody(node)

)

]

)

)

]),

/*location*/ node.statements

)

);

addEmitHelpers(updated, context.readEmitHelpers());

return updated;

}

/**

function transformUMDModule(node: SourceFile) {

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

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

const umdHeader = factory.createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

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

/*type*/ undefined,

setTextRange(

factory.createBlock(

[

factory.createIfStatement(

factory.createLogicalAnd(

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

factory.createTypeCheck(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), "object")

),

factory.createBlock([

factory.createVariableStatement(

/*modifiers*/ undefined,

[

factory.createVariableDeclaration(

"v",

/*exclamationToken*/ undefined,

/*type*/ undefined,

factory.createCallExpression(

factory.createIdentifier("factory"),

/*typeArguments*/ undefined,

[

factory.createIdentifier("require"),

factory.createIdentifier("exports")

]

)

)

]

),

setEmitFlags(

factory.createIfStatement(

factory.createStrictInequality(

factory.createIdentifier("v"),

factory.createIdentifier("undefined")

),

factory.createExpressionStatement(

factory.createAssignment(

factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"),

factory.createIdentifier("v")

)

)

),

EmitFlags.SingleLine

)

]),

factory.createIfStatement(

factory.createLogicalAnd(

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

factory.createPropertyAccessExpression(factory.createIdentifier("define"), "amd")

),

factory.createBlock([

factory.createExpressionStatement(

factory.createCallExpression(

factory.createIdentifier("define"),

/*typeArguments*/ undefined,

[

// Add the module name (if provided).

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

factory.createArrayLiteralExpression([

factory.createStringLiteral("require"),

factory.createStringLiteral("exports"),

...aliasedModuleNames,

...unaliasedModuleNames

]),

factory.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 ...)

const updated = factory.updateSourceFile(

node,

setTextRange(

factory.createNodeArray([

factory.createExpressionStatement(

factory.createCallExpression(

umdHeader,

/*typeArguments*/ undefined,

[

// Add the module body function argument:

//

// function (require, exports) ...

factory.createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

[

factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),

factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),

...importAliasNames

],

/*type*/ undefined,

transformAsynchronousModuleBody(node)

)

]

)

)

]),

/*location*/ node.statements

)

);

addEmitHelpers(updated, context.readEmitHelpers());

return updated;

}

/**

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(factory.createStringLiteral(amdDependency.path));

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

}

else {

unaliasedModuleNames.push(factory.createStringLiteral(amdDependency.path));

}

}

for (const importNode of currentModuleInfo.externalImports) {

// Find the name of the external module

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

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

const importAliasName = getLocalNameForExternalImport(factory, 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(factory.createParameterDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, importAliasName));

}

else {

unaliasedModuleNames.push(externalModuleName);

}

}

}

return { aliasedModuleNames, unaliasedModuleNames, importAliasNames };

}

function getAMDImportExpressionForImport(node: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration) {

if (isImportEqualsDeclaration(node) || isExportDeclaration(node) || !getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions)) {

return undefined;

}

const name = getLocalNameForExternalImport(factory, node, currentSourceFile)!; // TODO: GH#18217

const expr = getHelperExpressionForImport(node, name);

if (expr === name) {

return undefined;

}

return factory.createExpressionStatement(factory.createAssignment(name, expr));

}

/**

function transformAsynchronousModuleBody(node: SourceFile) {

startLexicalEnvironment();

const statements: Statement[] = [];

const statementOffset = factory.copyPrologue(node.statements, statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, topLevelVisitor);

if (shouldEmitUnderscoreUnderscoreESModule()) {

append(statements, createUnderscoreUnderscoreESModule());

}

if (length(currentModuleInfo.exportedNames)) {

append(statements, factory.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(idText(nextId))), prev), factory.createVoidZero() as Expression)));

}

// Visit each statement of the module body.

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

if (moduleKind === ModuleKind.AMD) {

addRange(statements, mapDefined(currentModuleInfo.externalImports, getAMDImportExpressionForImport));

}

addRange(statements, visitNodes(node.statements, topLevelVisitor, 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.

insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());

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

if (needUMDDynamicImportHelper) {

addEmitHelper(body, dynamicImportUMDHelper);

}

return body;

}

/**

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

if (currentModuleInfo.exportEquals) {

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

if (expressionResult) {

if (emitAsReturn) {

const statement = factory.createReturnStatement(expressionResult);

setTextRange(statement, currentModuleInfo.exportEquals);

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

statements.push(statement);

}

else {

const statement = factory.createExpressionStatement(

factory.createAssignment(

factory.createPropertyAccessExpression(

factory.createIdentifier("module"),

"exports"

),

expressionResult

)

);

setTextRange(statement, currentModuleInfo.exportEquals);

setEmitFlags(statement, EmitFlags.NoComments);

statements.push(statement);

}

}

}

}

//

// Top-Level Source Element Visitors

//

/**

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

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

return visitImportDeclaration(node as ImportDeclaration);

case SyntaxKind.ImportEqualsDeclaration:

return visitImportEqualsDeclaration(node as ImportEqualsDeclaration);

case SyntaxKind.ExportDeclaration:

return visitExportDeclaration(node as ExportDeclaration);

case SyntaxKind.ExportAssignment:

return visitExportAssignment(node as ExportAssignment);

case SyntaxKind.VariableStatement:

return visitVariableStatement(node as VariableStatement);

case SyntaxKind.FunctionDeclaration:

return visitFunctionDeclaration(node as FunctionDeclaration);

case SyntaxKind.ClassDeclaration:

return visitClassDeclaration(node as ClassDeclaration);

case SyntaxKind.MergeDeclarationMarker:

return visitMergeDeclarationMarker(node as MergeDeclarationMarker);

case SyntaxKind.EndOfDeclarationMarker:

return visitEndOfDeclarationMarker(node as EndOfDeclarationMarker);

default:

return visitor(node);

}

}

function visitorWorker(node: Node, valueIsDiscarded: boolean): VisitResult<Node> {

// This visitor does not need to descend into the tree if there is no dynamic import, destructuring assignment, or update expression

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

if (!(node.transformFlags & (TransformFlags.ContainsDynamicImport | TransformFlags.ContainsDestructuringAssignment | TransformFlags.ContainsUpdateExpressionForIdentifier))) {

return node;

}

switch (node.kind) {

case SyntaxKind.ForStatement:

return visitForStatement(node as ForStatement);

case SyntaxKind.ExpressionStatement:

return visitExpressionStatement(node as ExpressionStatement);

case SyntaxKind.ParenthesizedExpression:

return visitParenthesizedExpression(node as ParenthesizedExpression, valueIsDiscarded);

case SyntaxKind.PartiallyEmittedExpression:

return visitPartiallyEmittedExpression(node as PartiallyEmittedExpression, valueIsDiscarded);

case SyntaxKind.CallExpression:

if (isImportCall(node) && currentSourceFile.impliedNodeFormat === undefined) {

return visitImportCallExpression(node);

}

break;

case SyntaxKind.BinaryExpression:

if (isDestructuringAssignment(node)) {

return visitDestructuringAssignment(node, valueIsDiscarded);

}

break;

case SyntaxKind.PrefixUnaryExpression:

case SyntaxKind.PostfixUnaryExpression:

return visitPreOrPostfixUnaryExpression(node as PrefixUnaryExpression | PostfixUnaryExpression, valueIsDiscarded);

}

return visitEachChild(node, visitor, context);

}

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

return visitorWorker(node, /*valueIsDiscarded*/ false);

}

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

return visitorWorker(node, /*valueIsDiscarded*/ true);

}

function destructuringNeedsFlattening(node: Expression): boolean {

if (isObjectLiteralExpression(node)) {

for (const elem of node.properties) {

switch (elem.kind) {

case SyntaxKind.PropertyAssignment:

if (destructuringNeedsFlattening(elem.initializer)) {

return true;

}

break;

case SyntaxKind.ShorthandPropertyAssignment:

if (destructuringNeedsFlattening(elem.name)) {

return true;

}

break;

case SyntaxKind.SpreadAssignment:

if (destructuringNeedsFlattening(elem.expression)) {

return true;

}

break;

case SyntaxKind.MethodDeclaration:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

return false;

default: Debug.assertNever(elem, "Unhandled object member kind");

}

}

}

else if (isArrayLiteralExpression(node)) {

for (const elem of node.elements) {

if (isSpreadElement(elem)) {

if (destructuringNeedsFlattening(elem.expression)) {

return true;

}

}

else if (destructuringNeedsFlattening(elem)) {

return true;

}

}

}

else if (isIdentifier(node)) {

return length(getExports(node)) > (isExportName(node) ? 1 : 0);

}

return false;

}

function visitDestructuringAssignment(node: DestructuringAssignment, valueIsDiscarded: boolean): Expression {

if (destructuringNeedsFlattening(node.left)) {

return flattenDestructuringAssignment(node, visitor, context, FlattenLevel.All, !valueIsDiscarded, createAllExportExpressions);

}

return visitEachChild(node, visitor, context);

}

function visitForStatement(node: ForStatement) {

return factory.updateForStatement(

node,

visitNode(node.initializer, discardedValueVisitor, isForInitializer),

visitNode(node.condition, visitor, isExpression),

visitNode(node.incrementor, discardedValueVisitor, isExpression),

visitIterationBody(node.statement, visitor, context)

);

}

function visitExpressionStatement(node: ExpressionStatement) {

return factory.updateExpressionStatement(

node,

visitNode(node.expression, discardedValueVisitor, isExpression)

);

}

function visitParenthesizedExpression(node: ParenthesizedExpression, valueIsDiscarded: boolean) {

return factory.updateParenthesizedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));

}

function visitPartiallyEmittedExpression(node: PartiallyEmittedExpression, valueIsDiscarded: boolean) {

return factory.updatePartiallyEmittedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));

}

function visitPreOrPostfixUnaryExpression(node: PrefixUnaryExpression | PostfixUnaryExpression, valueIsDiscarded: boolean) {

// When we see a prefix or postfix increment expression whose operand is an exported

// symbol, we should ensure all exports of that symbol are updated with the correct

// value.

//

// - We do not transform generated identifiers for any reason.

// - We do not transform identifiers tagged with the LocalName flag.

// - We do not transform identifiers that were originally the name of an enum or

// namespace due to how they are transformed in TypeScript.

// - We only transform identifiers that are exported at the top level.

if ((node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken)

&& isIdentifier(node.operand)

&& !isGeneratedIdentifier(node.operand)

&& !isLocalName(node.operand)

&& !isDeclarationNameOfEnumOrNamespace(node.operand)) {

const exportedNames = getExports(node.operand);

if (exportedNames) {

let temp: Identifier | undefined;

let expression: Expression = visitNode(node.operand, visitor, isExpression);

if (isPrefixUnaryExpression(node)) {

expression = factory.updatePrefixUnaryExpression(node, expression);

}

else {

expression = factory.updatePostfixUnaryExpression(node, expression);

if (!valueIsDiscarded) {

temp = factory.createTempVariable(hoistVariableDeclaration);

expression = factory.createAssignment(temp, expression);

setTextRange(expression, node);

}

expression = factory.createComma(expression, factory.cloneNode(node.operand));

setTextRange(expression, node);

}

for (const exportName of exportedNames) {

noSubstitution[getNodeId(expression)] = true;

expression = createExportExpression(exportName, expression);

setTextRange(expression, node);

}

if (temp) {

noSubstitution[getNodeId(expression)] = true;

expression = factory.createComma(expression, temp);

setTextRange(expression, node);

}

return expression;

}

}

return visitEachChild(node, visitor, context);

}

function visitImportCallExpression(node: ImportCall): Expression {

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

const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor);

// Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output.

const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;

const containsLexicalThis = !!(node.transformFlags & TransformFlags.ContainsLexicalThis);

switch (compilerOptions.module) {

case ModuleKind.AMD:

return createImportCallExpressionAMD(argument, containsLexicalThis);

case ModuleKind.UMD:

return createImportCallExpressionUMD(argument ?? factory.createVoidZero(), containsLexicalThis);

case ModuleKind.CommonJS:

default:

return createImportCallExpressionCommonJS(argument, containsLexicalThis);

}

}

function createImportCallExpressionUMD(arg: Expression, containsLexicalThis: boolean): 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;

if (isSimpleCopiableExpression(arg)) {

const argClone = isGeneratedIdentifier(arg) ? arg : isStringLiteral(arg) ? factory.createStringLiteralFromNode(arg) : setEmitFlags(setTextRange(factory.cloneNode(arg), arg), EmitFlags.NoComments);

return factory.createConditionalExpression(

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

/*questionToken*/ undefined,

/*whenTrue*/ createImportCallExpressionCommonJS(arg, containsLexicalThis),

/*colonToken*/ undefined,

/*whenFalse*/ createImportCallExpressionAMD(argClone, containsLexicalThis)

);

}

else {

const temp = factory.createTempVariable(hoistVariableDeclaration);

return factory.createComma(factory.createAssignment(temp, arg), factory.createConditionalExpression(

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

/*questionToken*/ undefined,

/*whenTrue*/ createImportCallExpressionCommonJS(temp, containsLexicalThis),

/*colonToken*/ undefined,

/*whenFalse*/ createImportCallExpressionAMD(temp, containsLexicalThis)

));

}

}

function createImportCallExpressionAMD(arg: Expression | undefined, containsLexicalThis: boolean): 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 = factory.createUniqueName("resolve");

const reject = factory.createUniqueName("reject");

const parameters = [

factory.createParameterDeclaration(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve),

factory.createParameterDeclaration(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject)

];

const body = factory.createBlock([

factory.createExpressionStatement(

factory.createCallExpression(

factory.createIdentifier("require"),

/*typeArguments*/ undefined,

[factory.createArrayLiteralExpression([arg || factory.createOmittedExpression()]), resolve, reject]

)

)

]);

let func: FunctionExpression | ArrowFunction;

if (languageVersion >= ScriptTarget.ES2015) {

func = factory.createArrowFunction(

/*modifiers*/ undefined,

/*typeParameters*/ undefined,

parameters,

/*type*/ undefined,

/*equalsGreaterThanToken*/ undefined,

body);

}

else {

func = factory.createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

parameters,

/*type*/ undefined,

body);

// if there is a lexical 'this' in the import call arguments, ensure we indicate

// that this new function expression indicates it captures 'this' so that the

// es2015 transformer will properly substitute 'this' with '_this'.

if (containsLexicalThis) {

setEmitFlags(func, EmitFlags.CapturesThis);

}

}

const promise = factory.createNewExpression(factory.createIdentifier("Promise"), /*typeArguments*/ undefined, [func]);

if (getESModuleInterop(compilerOptions)) {

return factory.createCallExpression(factory.createPropertyAccessExpression(promise, factory.createIdentifier("then")), /*typeArguments*/ undefined, [emitHelpers().createImportStarCallbackHelper()]);

}

return promise;

}

function createImportCallExpressionCommonJS(arg: Expression | undefined, containsLexicalThis: boolean): 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

const promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []);

let requireCall: Expression = factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []);

if (getESModuleInterop(compilerOptions)) {

requireCall = emitHelpers().createImportStarHelper(requireCall);

}

let func: FunctionExpression | ArrowFunction;

if (languageVersion >= ScriptTarget.ES2015) {

func = factory.createArrowFunction(

/*modifiers*/ undefined,

/*typeParameters*/ undefined,

/*parameters*/ [],

/*type*/ undefined,

/*equalsGreaterThanToken*/ undefined,

requireCall);

}

else {

func = factory.createFunctionExpression(

/*modifiers*/ undefined,

/*asteriskToken*/ undefined,

/*name*/ undefined,

/*typeParameters*/ undefined,

/*parameters*/ [],

/*type*/ undefined,

factory.createBlock([factory.createReturnStatement(requireCall)]));

// if there is a lexical 'this' in the import call arguments, ensure we indicate

// that this new function expression indicates it captures 'this' so that the

// es2015 transformer will properly substitute 'this' with '_this'.

if (containsLexicalThis) {

setEmitFlags(func, EmitFlags.CapturesThis);