host: EmitHost, action: (emitFileNames: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle | undefined) => T,

sourceFilesOrTargetSourceFile?: readonly SourceFile[] | SourceFile,

forceDtsEmit = false,

onlyBuildInfo?: boolean,

includeBuildInfo?: boolean) {

const sourceFiles = isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile, forceDtsEmit);

const options = host.getCompilerOptions();

if (outFile(options)) {

const prepends = host.getPrependNodes();

if (sourceFiles.length || prepends.length) {

const bundle = factory.createBundle(sourceFiles, prepends);

const result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle);

if (result) {

return result;

}

}

}

else {

if (!onlyBuildInfo) {

for (const sourceFile of sourceFiles) {

const result = action(getOutputPathsFor(sourceFile, host, forceDtsEmit), sourceFile);

if (result) {

return result;

}

}

}

if (includeBuildInfo) {

const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);

if (buildInfoPath) return action({ buildInfoPath }, /*sourceFileOrBundle*/ undefined);

}

}

const configFile = options.configFilePath;

if (!isIncrementalCompilation(options)) return undefined;

if (options.tsBuildInfoFile) return options.tsBuildInfoFile;

const outPath = outFile(options);

let buildInfoExtensionLess: string;

if (outPath) {

buildInfoExtensionLess = removeFileExtension(outPath);

}

else {

if (!configFile) return undefined;

const configFileExtensionLess = removeFileExtension(configFile);

buildInfoExtensionLess = options.outDir ?

options.rootDir ?

resolvePath(options.outDir, getRelativePathFromDirectory(options.rootDir, configFileExtensionLess, /*ignoreCase*/ true)) :

combinePaths(options.outDir, getBaseFileName(configFileExtensionLess)) :

configFileExtensionLess;

}

return buildInfoExtensionLess + Extension.TsBuildInfo;

const outPath = outFile(options)!;

const jsFilePath = options.emitDeclarationOnly ? undefined : outPath;

const sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options);

const declarationFilePath = (forceDtsPaths || getEmitDeclarations(options)) ? removeFileExtension(outPath) + Extension.Dts : undefined;

const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;

const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);

return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath };

const options = host.getCompilerOptions();

if (sourceFile.kind === SyntaxKind.Bundle) {

return getOutputPathsForBundle(options, forceDtsPaths);

}

else {

const ownOutputFilePath = getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile, options));

const isJsonFile = isJsonSourceFile(sourceFile);

// If json file emits to the same location skip writing it, if emitDeclarationOnly skip writing it

const isJsonEmittedToSameLocation = isJsonFile &&

comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;

const jsFilePath = options.emitDeclarationOnly || isJsonEmittedToSameLocation ? undefined : ownOutputFilePath;

const sourceMapFilePath = !jsFilePath || isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options);

const declarationFilePath = (forceDtsPaths || (getEmitDeclarations(options) && !isJsonFile)) ? getDeclarationEmitOutputFilePath(sourceFile.fileName, host) : undefined;

const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;

return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath: undefined };

}

if (isJsonSourceFile(sourceFile)) {

return Extension.Json;

}

if (options.jsx === JsxEmit.Preserve) {

if (isSourceFileJS(sourceFile)) {

if (fileExtensionIs(sourceFile.fileName, Extension.Jsx)) {

return Extension.Jsx;

}

}

else if (sourceFile.languageVariant === LanguageVariant.JSX) {

// TypeScript source file preserving JSX syntax

return Extension.Jsx;

}

}

return Extension.Js;

return outputDir ?

resolvePath(

outputDir,

getRelativePathFromDirectory(rootDirOfOptions(configFile), inputFileName, ignoreCase)

) :

inputFileName;

Debug.assert(!fileExtensionIs(inputFileName, Extension.Dts) && !fileExtensionIs(inputFileName, Extension.Json));

return changeExtension(

getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir),

Extension.Dts

);

if (configFile.options.emitDeclarationOnly) return undefined;

const isJsonFile = fileExtensionIs(inputFileName, Extension.Json);

const outputFileName = changeExtension(

getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir),

isJsonFile ?

Extension.Json :

fileExtensionIs(inputFileName, Extension.Tsx) && configFile.options.jsx === JsxEmit.Preserve ?

Extension.Jsx :

Extension.Js

);

return !isJsonFile || comparePaths(inputFileName, outputFileName, Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== Comparison.EqualTo ?

outputFileName :

undefined;

let outputs: string[] | undefined;

return { addOutput, getOutputs };

function addOutput(path: string | undefined) {

if (path) {

(outputs || (outputs = [])).push(path);

}

}

function getOutputs(): readonly string[] {

return outputs || emptyArray;

}

const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(configFile.options, /*forceDtsPaths*/ false);

addOutput(jsFilePath);

addOutput(sourceMapFilePath);

addOutput(declarationFilePath);

addOutput(declarationMapPath);

addOutput(buildInfoPath);

if (fileExtensionIs(inputFileName, Extension.Dts)) return;

const js = getOutputJSFileName(inputFileName, configFile, ignoreCase);

addOutput(js);

if (fileExtensionIs(inputFileName, Extension.Json)) return;

if (js && configFile.options.sourceMap) {

addOutput(`${js}.map`);

}

if (getEmitDeclarations(configFile.options)) {

const dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase);

addOutput(dts);

if (configFile.options.declarationMap) {

addOutput(`${dts}.map`);

}

}

const { addOutput, getOutputs } = createAddOutput();

if (outFile(configFile.options)) {

getSingleOutputFileNames(configFile, addOutput);

}

else {

for (const inputFileName of configFile.fileNames) {

getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput);

}

addOutput(getTsBuildInfoEmitOutputFilePath(configFile.options));

}

return getOutputs();

inputFileName = normalizePath(inputFileName);

Debug.assert(contains(commandLine.fileNames, inputFileName), `Expected fileName to be present in command line`);

const { addOutput, getOutputs } = createAddOutput();

if (outFile(commandLine.options)) {

getSingleOutputFileNames(commandLine, addOutput);

}

else {

getOwnOutputFileNames(commandLine, inputFileName, ignoreCase, addOutput);

}

return getOutputs();

if (outFile(configFile.options)) {

const { jsFilePath } = getOutputPathsForBundle(configFile.options, /*forceDtsPaths*/ false);

return Debug.checkDefined(jsFilePath, `project ${configFile.options.configFilePath} expected to have at least one output`);

}

for (const inputFileName of configFile.fileNames) {

if (fileExtensionIs(inputFileName, Extension.Dts)) continue;

const jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase);

if (jsFilePath) return jsFilePath;

if (fileExtensionIs(inputFileName, Extension.Json)) continue;

if (getEmitDeclarations(configFile.options)) {

return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase);

}

}

const buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options);

if (buildInfoPath) return buildInfoPath;

return Debug.fail(`project ${configFile.options.configFilePath} expected to have at least one output`);

const compilerOptions = host.getCompilerOptions();

const sourceMapDataList: SourceMapEmitResult[] | undefined = (compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions)) ? [] : undefined;

const emittedFilesList: string[] | undefined = compilerOptions.listEmittedFiles ? [] : undefined;

const emitterDiagnostics = createDiagnosticCollection();

const newLine = getNewLineCharacter(compilerOptions, () => host.getNewLine());

const writer = createTextWriter(newLine);

const { enter, exit } = performance.createTimer("printTime", "beforePrint", "afterPrint");

let bundleBuildInfo: BundleBuildInfo | undefined;

let emitSkipped = false;

let exportedModulesFromDeclarationEmit: ExportedModulesFromDeclarationEmit | undefined;

// Emit each output file

enter();

forEachEmittedFile(

host,

emitSourceFileOrBundle,

getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit),

forceDtsEmit,

onlyBuildInfo,

!targetSourceFile

);

exit();

return {

emitSkipped,

diagnostics: emitterDiagnostics.getDiagnostics(),

emittedFiles: emittedFilesList,

sourceMaps: sourceMapDataList,

exportedModulesFromDeclarationEmit

};

function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle | undefined) {

let buildInfoDirectory: string | undefined;

if (buildInfoPath && sourceFileOrBundle && isBundle(sourceFileOrBundle)) {

buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));

bundleBuildInfo = {

commonSourceDirectory: relativeToBuildInfo(host.getCommonSourceDirectory()),

sourceFiles: sourceFileOrBundle.sourceFiles.map(file => relativeToBuildInfo(getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())))

};

}

tracing.begin(tracing.Phase.Emit, "emitJsFileOrBundle", { jsFilePath });

emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo);

tracing.end();

tracing.begin(tracing.Phase.Emit, "emitDeclarationFileOrBundle", { declarationFilePath });

emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo);

tracing.end();

tracing.begin(tracing.Phase.Emit, "emitBuildInfo", { buildInfoPath });

emitBuildInfo(bundleBuildInfo, buildInfoPath);

tracing.end();

if (!emitSkipped && emittedFilesList) {

if (!emitOnlyDtsFiles) {

if (jsFilePath) {

emittedFilesList.push(jsFilePath);

}

if (sourceMapFilePath) {

emittedFilesList.push(sourceMapFilePath);

}

if (buildInfoPath) {

emittedFilesList.push(buildInfoPath);

}

}

if (declarationFilePath) {

emittedFilesList.push(declarationFilePath);

}

if (declarationMapPath) {

emittedFilesList.push(declarationMapPath);

}

}

function relativeToBuildInfo(path: string) {

return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory!, path, host.getCanonicalFileName));

}

}

function emitBuildInfo(bundle: BundleBuildInfo | undefined, buildInfoPath: string | undefined) {

// Write build information if applicable

if (!buildInfoPath || targetSourceFile || emitSkipped) return;

const program = host.getProgramBuildInfo();

if (host.isEmitBlocked(buildInfoPath)) {

emitSkipped = true;

return;

}

const version = ts.version; // Extracted into a const so the form is stable between namespace and module

writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText({ bundle, program, version }), /*writeByteOrderMark*/ false);

}

function emitJsFileOrBundle(

sourceFileOrBundle: SourceFile | Bundle | undefined,

jsFilePath: string | undefined,

sourceMapFilePath: string | undefined,

relativeToBuildInfo: (path: string) => string) {

if (!sourceFileOrBundle || emitOnlyDtsFiles || !jsFilePath) {

return;

}

// Make sure not to write js file and source map file if any of them cannot be written

if ((jsFilePath && host.isEmitBlocked(jsFilePath)) || compilerOptions.noEmit) {

emitSkipped = true;

return;

}

// Transform the source files

const transform = transformNodes(resolver, host, factory, compilerOptions, [sourceFileOrBundle], scriptTransformers, /*allowDtsFiles*/ false);

const printerOptions: PrinterOptions = {

removeComments: compilerOptions.removeComments,

newLine: compilerOptions.newLine,

noEmitHelpers: compilerOptions.noEmitHelpers,

module: compilerOptions.module,

target: compilerOptions.target,

sourceMap: compilerOptions.sourceMap,

inlineSourceMap: compilerOptions.inlineSourceMap,

inlineSources: compilerOptions.inlineSources,

extendedDiagnostics: compilerOptions.extendedDiagnostics,

writeBundleFileInfo: !!bundleBuildInfo,

relativeToBuildInfo

};

// Create a printer to print the nodes

const printer = createPrinter(printerOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// transform hooks

onEmitNode: transform.emitNodeWithNotification,

isEmitNotificationEnabled: transform.isEmitNotificationEnabled,

substituteNode: transform.substituteNode,

});

Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");

printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform.transformed[0], printer, compilerOptions);

// Clean up emit nodes on parse tree

transform.dispose();

if (bundleBuildInfo) bundleBuildInfo.js = printer.bundleFileInfo;

}

function emitDeclarationFileOrBundle(

sourceFileOrBundle: SourceFile | Bundle | undefined,

declarationFilePath: string | undefined,

declarationMapPath: string | undefined,

relativeToBuildInfo: (path: string) => string) {

if (!sourceFileOrBundle) return;

if (!declarationFilePath) {

if (emitOnlyDtsFiles || compilerOptions.emitDeclarationOnly) emitSkipped = true;

return;

}

const sourceFiles = isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles;

const filesForEmit = forceDtsEmit ? sourceFiles : filter(sourceFiles, isSourceFileNotJson);

// Setup and perform the transformation to retrieve declarations from the input files

const inputListOrBundle = outFile(compilerOptions) ? [factory.createBundle(filesForEmit, !isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : filesForEmit;

if (emitOnlyDtsFiles && !getEmitDeclarations(compilerOptions)) {

// Checker wont collect the linked aliases since thats only done when declaration is enabled.

// Do that here when emitting only dts files

filesForEmit.forEach(collectLinkedAliases);

}

const declarationTransform = transformNodes(resolver, host, factory, compilerOptions, inputListOrBundle, declarationTransformers, /*allowDtsFiles*/ false);

if (length(declarationTransform.diagnostics)) {

for (const diagnostic of declarationTransform.diagnostics!) {

emitterDiagnostics.add(diagnostic);

}

}

const printerOptions: PrinterOptions = {

removeComments: compilerOptions.removeComments,

newLine: compilerOptions.newLine,

noEmitHelpers: true,

module: compilerOptions.module,

target: compilerOptions.target,

sourceMap: compilerOptions.sourceMap,

inlineSourceMap: compilerOptions.inlineSourceMap,

extendedDiagnostics: compilerOptions.extendedDiagnostics,

onlyPrintJsDocStyle: true,

writeBundleFileInfo: !!bundleBuildInfo,

recordInternalSection: !!bundleBuildInfo,

relativeToBuildInfo

};

const declarationPrinter = createPrinter(printerOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// transform hooks

onEmitNode: declarationTransform.emitNodeWithNotification,

isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,

substituteNode: declarationTransform.substituteNode,

});

const declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;

emitSkipped = emitSkipped || declBlocked;

if (!declBlocked || forceDtsEmit) {

Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");

printSourceFileOrBundle(

declarationFilePath,

declarationMapPath,

declarationTransform.transformed[0],

declarationPrinter,

{

sourceMap: compilerOptions.declarationMap,

sourceRoot: compilerOptions.sourceRoot,

mapRoot: compilerOptions.mapRoot,

extendedDiagnostics: compilerOptions.extendedDiagnostics,

// Explicitly do not passthru either `inline` option

}

);

if (forceDtsEmit && declarationTransform.transformed[0].kind === SyntaxKind.SourceFile) {

const sourceFile = declarationTransform.transformed[0];

exportedModulesFromDeclarationEmit = sourceFile.exportedModulesFromDeclarationEmit;

}

}

declarationTransform.dispose();

if (bundleBuildInfo) bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;

}

function collectLinkedAliases(node: Node) {

if (isExportAssignment(node)) {

if (node.expression.kind === SyntaxKind.Identifier) {

resolver.collectLinkedAliases(node.expression as Identifier, /*setVisibility*/ true);

}

return;

}

else if (isExportSpecifier(node)) {

resolver.collectLinkedAliases(node.propertyName || node.name, /*setVisibility*/ true);

return;

}

forEachChild(node, collectLinkedAliases);

}

function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string | undefined, sourceFileOrBundle: SourceFile | Bundle, printer: Printer, mapOptions: SourceMapOptions) {

const bundle = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle : undefined;

const sourceFile = sourceFileOrBundle.kind === SyntaxKind.SourceFile ? sourceFileOrBundle : undefined;

const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile!];

let sourceMapGenerator: SourceMapGenerator | undefined;

if (shouldEmitSourceMaps(mapOptions, sourceFileOrBundle)) {

sourceMapGenerator = createSourceMapGenerator(

host,

getBaseFileName(normalizeSlashes(jsFilePath)),

getSourceRoot(mapOptions),

getSourceMapDirectory(mapOptions, jsFilePath, sourceFile),

mapOptions);

}

if (bundle) {

printer.writeBundle(bundle, writer, sourceMapGenerator);

}

else {

printer.writeFile(sourceFile!, writer, sourceMapGenerator);

}

if (sourceMapGenerator) {

if (sourceMapDataList) {

sourceMapDataList.push({

inputSourceFileNames: sourceMapGenerator.getSources(),

sourceMap: sourceMapGenerator.toJSON()

});

}

const sourceMappingURL = getSourceMappingURL(

mapOptions,

sourceMapGenerator,

jsFilePath,

sourceMapFilePath,

sourceFile);

if (sourceMappingURL) {

if (!writer.isAtStartOfLine()) writer.rawWrite(newLine);

writer.writeComment(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Tools can sometimes see this line as a source mapping url comment

}

// Write the source map

if (sourceMapFilePath) {

const sourceMap = sourceMapGenerator.toString();

writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);

}

}

else {

writer.writeLine();

}

// Write the output file

writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles);

// Reset state

writer.clear();

}

interface SourceMapOptions {

sourceMap?: boolean;

inlineSourceMap?: boolean;

inlineSources?: boolean;

sourceRoot?: string;

mapRoot?: string;

extendedDiagnostics?: boolean;

}

function shouldEmitSourceMaps(mapOptions: SourceMapOptions, sourceFileOrBundle: SourceFile | Bundle) {

return (mapOptions.sourceMap || mapOptions.inlineSourceMap)

&& (sourceFileOrBundle.kind !== SyntaxKind.SourceFile || !fileExtensionIs(sourceFileOrBundle.fileName, Extension.Json));

}

function getSourceRoot(mapOptions: SourceMapOptions) {

// Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the

// relative paths of the sources list in the sourcemap

const sourceRoot = normalizeSlashes(mapOptions.sourceRoot || "");

return sourceRoot ? ensureTrailingDirectorySeparator(sourceRoot) : sourceRoot;

}

function getSourceMapDirectory(mapOptions: SourceMapOptions, filePath: string, sourceFile: SourceFile | undefined) {

if (mapOptions.sourceRoot) return host.getCommonSourceDirectory();

if (mapOptions.mapRoot) {

let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);

if (sourceFile) {

// For modules or multiple emit files the mapRoot will have directory structure like the sources

// So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map

sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir));

}

if (getRootLength(sourceMapDir) === 0) {

// The relative paths are relative to the common directory

sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);

}

return sourceMapDir;

}

return getDirectoryPath(normalizePath(filePath));

}

function getSourceMappingURL(mapOptions: SourceMapOptions, sourceMapGenerator: SourceMapGenerator, filePath: string, sourceMapFilePath: string | undefined, sourceFile: SourceFile | undefined) {

if (mapOptions.inlineSourceMap) {

// Encode the sourceMap into the sourceMap url

const sourceMapText = sourceMapGenerator.toString();

const base64SourceMapText = base64encode(sys, sourceMapText);

return `data:application/json;base64,${base64SourceMapText}`;

}

const sourceMapFile = getBaseFileName(normalizeSlashes(Debug.checkDefined(sourceMapFilePath)));

if (mapOptions.mapRoot) {

let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);

if (sourceFile) {

// For modules or multiple emit files the mapRoot will have directory structure like the sources

// So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map

sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir));

}

if (getRootLength(sourceMapDir) === 0) {

// The relative paths are relative to the common directory

sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);

return getRelativePathToDirectoryOrUrl(

getDirectoryPath(normalizePath(filePath)), // get the relative sourceMapDir path based on jsFilePath

combinePaths(sourceMapDir, sourceMapFile), // this is where user expects to see sourceMap

host.getCurrentDirectory(),

host.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true);

}

else {

return combinePaths(sourceMapDir, sourceMapFile);

}

}

return sourceMapFile;

}

getCurrentDirectory(): string;

getCanonicalFileName(fileName: string): string;

useCaseSensitiveFileNames(): boolean;

getNewLine(): string;

const jsBundle = Debug.checkDefined(bundle.js);

const prologueMap = jsBundle.sources?.prologues && arrayToMap(jsBundle.sources.prologues, prologueInfo => prologueInfo.file);

return bundle.sourceFiles.map((fileName, index) => {

const prologueInfo = prologueMap?.get(index);

const statements = prologueInfo?.directives.map(directive => {

const literal = setTextRange(factory.createStringLiteral(directive.expression.text), directive.expression);

const statement = setTextRange(factory.createExpressionStatement(literal), directive);

setParent(literal, statement);

return statement;

});

const eofToken = factory.createToken(SyntaxKind.EndOfFileToken);

const sourceFile = factory.createSourceFile(statements ?? [], eofToken, NodeFlags.None);

sourceFile.fileName = getRelativePathFromDirectory(

host.getCurrentDirectory(),

getNormalizedAbsolutePath(fileName, buildInfoDirectory),

!host.useCaseSensitiveFileNames()

);

sourceFile.text = prologueInfo?.text ?? "";

setTextRangePosWidth(sourceFile, 0, prologueInfo?.text.length ?? 0);

setEachParent(sourceFile.statements, sourceFile);

setTextRangePosWidth(eofToken, sourceFile.end, 0);

setParent(eofToken, sourceFile);

return sourceFile;

});

config: ParsedCommandLine,

host: EmitUsingBuildInfoHost,

getCommandLine: (ref: ProjectReference) => ParsedCommandLine | undefined,

customTransformers?: CustomTransformers

): EmitUsingBuildInfoResult {

const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, /*forceDtsPaths*/ false);

const buildInfoText = host.readFile(Debug.checkDefined(buildInfoPath));

if (!buildInfoText) return buildInfoPath!;

const jsFileText = host.readFile(Debug.checkDefined(jsFilePath));

if (!jsFileText) return jsFilePath!;

const sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);

// error if no source map or for now if inline sourcemap

if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap) return sourceMapFilePath || "inline sourcemap decoding";

// read declaration text

const declarationText = declarationFilePath && host.readFile(declarationFilePath);

if (declarationFilePath && !declarationText) return declarationFilePath;

const declarationMapText = declarationMapPath && host.readFile(declarationMapPath);

// error if no source map or for now if inline sourcemap

if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap) return declarationMapPath || "inline sourcemap decoding";

const buildInfo = getBuildInfo(buildInfoText);