namespace ts {

const brackets = createBracketsMap();

const syntheticParent: TextRange = { pos: -1, end: -1 };

/*@internal*/

export function isBuildInfoFile(file: string) {

return fileExtensionIs(file, Extension.TsBuildInfo);

}

/*@internal*/

/**

* Iterates over the source files that are expected to have an emit output.

*

* @param host An EmitHost.

* @param action The action to execute.

* @param sourceFilesOrTargetSourceFile

* If an array, the full list of source files to emit.

* Else, calls `getSourceFilesToEmit` with the (optional) target source file to determine the list of source files to emit.

*/

export function forEachEmittedFile<T>(

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

sourceFilesOrTargetSourceFile?: ReadonlyArray<SourceFile> | SourceFile,

emitOnlyDtsFiles = false,

onlyBuildInfo?: boolean,

includeBuildInfo?: boolean) {

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

const options = host.getCompilerOptions();

if (options.outFile || options.out) {

const prepends = host.getPrependNodes();

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

const bundle = createBundle(sourceFiles, prepends);

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

if (result) {

return result;

}

}

}

else {

if (!onlyBuildInfo) {

for (const sourceFile of sourceFiles) {

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

if (result) {

return result;

}

}

}

if (includeBuildInfo) {

const buildInfoPath = getOutputPathForBuildInfo(host.getCompilerOptions());

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

}

}

}

/*@internal*/

export function getOutputPathForBuildInfo(options: CompilerOptions) {

const configFile = options.configFilePath;

if (!isIncrementalCompilation(options)) return undefined;

if (options.tsBuildInfoFile) return options.tsBuildInfoFile;

const outPath = options.outFile || options.out;

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;

}

/*@internal*/

export function getOutputPathsForBundle(options: CompilerOptions, forceDtsPaths: boolean): EmitFileNames {

const outPath = options.outFile || options.out!;

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 = getOutputPathForBuildInfo(options);

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

}

/*@internal*/

export function getOutputPathsFor(sourceFile: SourceFile | Bundle, host: EmitHost, forceDtsPaths: boolean): EmitFileNames {

const options = host.getCompilerOptions();

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

return getOutputPathsForBundle(options, forceDtsPaths);

}

else {

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

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

const isJsonEmittedToSameLocation = isJsonSourceFile(sourceFile) &&

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);

// For legacy reasons (ie, we have baselines capturing the behavior), js files don't report a .d.ts output path - this would only matter if `declaration` and `allowJs` were both on, which is currently an error

const isJs = isSourceFileJS(sourceFile);

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

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

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

}

}

function getSourceMapFilePath(jsFilePath: string, options: CompilerOptions) {

return (options.sourceMap && !options.inlineSourceMap) ? jsFilePath + ".map" : undefined;

}

// JavaScript files are always LanguageVariant.JSX, as JSX syntax is allowed in .js files also.

// So for JavaScript files, '.jsx' is only emitted if the input was '.jsx', and JsxEmit.Preserve.

// For TypeScript, the only time to emit with a '.jsx' extension, is on JSX input, and JsxEmit.Preserve

/* @internal */

export function getOutputExtension(sourceFile: SourceFile, options: CompilerOptions): Extension {

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;

}

function rootDirOfOptions(configFile: ParsedCommandLine) {

return configFile.options.rootDir || getDirectoryPath(Debug.assertDefined(configFile.options.configFilePath));

}

function getOutputPathWithoutChangingExt(inputFileName: string, configFile: ParsedCommandLine, ignoreCase: boolean, outputDir: string | undefined) {

return outputDir ?

resolvePath(

outputDir,

getRelativePathFromDirectory(rootDirOfOptions(configFile), inputFileName, ignoreCase)

) :

inputFileName;

}

/* @internal */

export function getOutputDeclarationFileName(inputFileName: string, configFile: ParsedCommandLine, ignoreCase: boolean) {

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

return changeExtension(

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

Extension.Dts

);

}

function getOutputJSFileName(inputFileName: string, configFile: ParsedCommandLine, ignoreCase: boolean) {

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.assertDefined(configFile.options.configFilePath), ignoreCase) !== Comparison.EqualTo ?

outputFileName :

undefined;

}

/*@internal*/

export function getAllProjectOutputs(configFile: ParsedCommandLine, ignoreCase: boolean): ReadonlyArray<string> {

let outputs: string[] | undefined;

const addOutput = (path: string | undefined) => path && (outputs || (outputs = [])).push(path);

if (configFile.options.outFile || configFile.options.out) {

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

addOutput(jsFilePath);

addOutput(sourceMapFilePath);

addOutput(declarationFilePath);

addOutput(declarationMapPath);

addOutput(buildInfoPath);

}

else {

for (const inputFileName of configFile.fileNames) {

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

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

addOutput(js);

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

if (configFile.options.sourceMap) {

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

}

if (getEmitDeclarations(configFile.options) && hasTSFileExtension(inputFileName)) {

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

addOutput(dts);

if (configFile.options.declarationMap) {

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

}

}

}

addOutput(getOutputPathForBuildInfo(configFile.options));

}

return outputs || emptyArray;

}

/*@internal*/

export function getFirstProjectOutput(configFile: ParsedCommandLine, ignoreCase: boolean): string {

if (configFile.options.outFile || configFile.options.out) {

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

return Debug.assertDefined(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;

}

const buildInfoPath = getOutputPathForBuildInfo(configFile.options);

if (buildInfoPath) return buildInfoPath;

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

}

/*@internal*/

// targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature

export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile | undefined, emitOnlyDtsFiles?: boolean, transformers?: TransformerFactory<Bundle | SourceFile>[], declarationTransformers?: TransformerFactory<Bundle | SourceFile>[], onlyBuildInfo?: boolean): EmitResult {

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), emitOnlyDtsFiles, 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) {

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

bundleBuildInfo = {

commonSourceDirectory: host.getCommonSourceDirectory(),

sourceFiles: sourceFileOrBundle.sourceFiles.map(file => file.fileName)

};

}

emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath);

emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath);

emitBuildInfo(bundleBuildInfo, buildInfoPath);

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 emitBuildInfo(bundle: BundleBuildInfo | undefined, buildInfoPath: string | undefined) {

// Write build information if applicable

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

const program = host.getProgramBuildInfo();

if (!bundle && !program) return;

if (host.isEmitBlocked(buildInfoPath) || compilerOptions.noEmit) {

emitSkipped = true;

return;

}

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

}

function emitJsFileOrBundle(sourceFileOrBundle: SourceFile | Bundle | undefined, jsFilePath: string | undefined, sourceMapFilePath: string | undefined) {

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, compilerOptions, [sourceFileOrBundle], transformers!, /*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

};

// Create a printer to print the nodes

const printer = createPrinter(printerOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// transform hooks

onEmitNode: transform.emitNodeWithNotification,

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) {

if (!sourceFileOrBundle || !(declarationFilePath && !isInJSFile(sourceFileOrBundle))) {

return;

}

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

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

const nonJsFiles = filter(sourceFiles, isSourceFileNotJS);

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

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

nonJsFiles.forEach(collectLinkedAliases);

}

const declarationTransform = transformNodes(resolver, host, compilerOptions, inputListOrBundle, concatenate([transformDeclarations], 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

};

const declarationPrinter = createPrinter(printerOptions, {

// resolver hooks

hasGlobalName: resolver.hasGlobalName,

// transform hooks

onEmitNode: declarationTransform.emitNodeWithNotification,

substituteNode: declarationTransform.substituteNode,

});

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

emitSkipped = emitSkipped || declBlocked;

if (!declBlocked || emitOnlyDtsFiles) {

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 (emitOnlyDtsFiles && declarationTransform.transformed[0].kind === SyntaxKind.SourceFile) {

const sourceFile = declarationTransform.transformed[0] as SourceFile;

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.assertDefined(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;

}

}

/*@internal*/

export function getBuildInfoText(buildInfo: BuildInfo) {

return JSON.stringify(buildInfo, undefined, 2);

}

/*@internal*/

export function getBuildInfo(buildInfoText: string) {

return JSON.parse(buildInfoText) as BuildInfo;

}

/*@internal*/

export const notImplementedResolver: EmitResolver = {

hasGlobalName: notImplemented,

getReferencedExportContainer: notImplemented,

getReferencedImportDeclaration: notImplemented,

getReferencedDeclarationWithCollidingName: notImplemented,

isDeclarationWithCollidingName: notImplemented,

isValueAliasDeclaration: notImplemented,

isReferencedAliasDeclaration: notImplemented,

isTopLevelValueImportEqualsWithEntityName: notImplemented,

getNodeCheckFlags: notImplemented,

isDeclarationVisible: notImplemented,

isLateBound: (_node): _node is LateBoundDeclaration => false,

collectLinkedAliases: notImplemented,

isImplementationOfOverload: notImplemented,

isRequiredInitializedParameter: notImplemented,

isOptionalUninitializedParameterProperty: notImplemented,

isExpandoFunctionDeclaration: notImplemented,

getPropertiesOfContainerFunction: notImplemented,

createTypeOfDeclaration: notImplemented,

createReturnTypeOfSignatureDeclaration: notImplemented,

createTypeOfExpression: notImplemented,

createLiteralConstValue: notImplemented,

isSymbolAccessible: notImplemented,

isEntityNameVisible: notImplemented,

// Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant

getConstantValue: notImplemented,

getReferencedValueDeclaration: notImplemented,

getTypeReferenceSerializationKind: notImplemented,

isOptionalParameter: notImplemented,

moduleExportsSomeValue: notImplemented,

isArgumentsLocalBinding: notImplemented,

getExternalModuleFileFromDeclaration: notImplemented,

getTypeReferenceDirectivesForEntityName: notImplemented,

getTypeReferenceDirectivesForSymbol: notImplemented,

isLiteralConstDeclaration: notImplemented,

getJsxFactoryEntity: notImplemented,

getAllAccessorDeclarations: notImplemented,

getSymbolOfExternalModuleSpecifier: notImplemented,

isBindingCapturedByNode: notImplemented,

};

/*@internal*/

/** File that isnt present resulting in error or output files */

export type EmitUsingBuildInfoResult = string | ReadonlyArray<OutputFile>;

/*@internal*/

export interface EmitUsingBuildInfoHost extends ModuleResolutionHost {

getCurrentDirectory(): string;

getCanonicalFileName(fileName: string): string;

useCaseSensitiveFileNames(): boolean;

getNewLine(): string;

}

function createSourceFilesFromBundleBuildInfo(bundle: BundleBuildInfo): ReadonlyArray<SourceFile> {

const sourceFiles = bundle.sourceFiles.map(fileName => {

const sourceFile = createNode(SyntaxKind.SourceFile, 0, 0) as SourceFile;

sourceFile.fileName = fileName;

sourceFile.text = "";

sourceFile.statements = createNodeArray();

return sourceFile;

});

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

forEach(jsBundle.sources && jsBundle.sources.prologues, prologueInfo => {

const sourceFile = sourceFiles[prologueInfo.file];

sourceFile.text = prologueInfo.text;

sourceFile.end = prologueInfo.text.length;

sourceFile.statements = createNodeArray(prologueInfo.directives.map(directive => {

const statement = createNode(SyntaxKind.ExpressionStatement, directive.pos, directive.end) as PrologueDirective;

statement.expression = createNode(SyntaxKind.StringLiteral, directive.expression.pos, directive.expression.end) as StringLiteral;

statement.expression.text = directive.expression.text;

return statement;

}));

});

return sourceFiles;

}

/*@internal*/

export function emitUsingBuildInfo(config: ParsedCommandLine, host: EmitUsingBuildInfoHost, getCommandLine: (ref: ProjectReference) => ParsedCommandLine | undefined): EmitUsingBuildInfoResult {

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

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

if (!buildInfoText) return buildInfoPath!;

const jsFileText = host.readFile(Debug.assertDefined(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);

if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationText && !buildInfo.bundle.dts)) return buildInfoPath!;

const ownPrependInput = createInputFiles(

jsFileText,

declarationText!,

sourceMapFilePath,

sourceMapText,

declarationMapPath,

declarationMapText,

jsFilePath,

declarationFilePath,

buildInfoPath,

buildInfo,

/*onlyOwnText*/ true

);

const outputFiles: OutputFile[] = [];

const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, f => host.readFile(f));

const sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle);

const emitHost: EmitHost = {

getPrependNodes: memoize(() => [...prependNodes, ownPrependInput]),

getCanonicalFileName: host.getCanonicalFileName,

getCommonSourceDirectory: () => buildInfo.bundle!.commonSourceDirectory,

getCompilerOptions: () => config.options,

getCurrentDirectory: () => host.getCurrentDirectory(),

getNewLine: () => host.getNewLine(),

getSourceFile: returnUndefined,

getSourceFileByPath: returnUndefined,

getSourceFiles: () => sourceFilesForJsEmit,

getLibFileFromReference: notImplemented,

isSourceFileFromExternalLibrary: returnFalse,

getResolvedProjectReferenceToRedirect: returnUndefined,

writeFile: (name, text, writeByteOrderMark) => {

switch (name) {

case jsFilePath:

if (jsFileText === text) return;

break;

case sourceMapFilePath:

if (sourceMapText === text) return;

break;

case buildInfoPath:

const newBuildInfo = getBuildInfo(text);

newBuildInfo.program = buildInfo.program;

// Update sourceFileInfo

const { js, dts, sourceFiles } = buildInfo.bundle!;

newBuildInfo.bundle!.js!.sources = js!.sources;

if (dts) {

newBuildInfo.bundle!.dts!.sources = dts.sources;

}

newBuildInfo.bundle!.sourceFiles = sourceFiles;

outputFiles.push({ name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark });

return;

case declarationFilePath:

if (declarationText === text) return;

break;

case declarationMapPath:

if (declarationMapText === text) return;

break;

default:

Debug.fail(`Unexpected path: ${name}`);

}

outputFiles.push({ name, text, writeByteOrderMark });

},

isEmitBlocked: returnFalse,

readFile: f => host.readFile(f),

fileExists: f => host.fileExists(f),

directoryExists: host.directoryExists && (f => host.directoryExists!(f)),

useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),

getProgramBuildInfo: returnUndefined

};

emitFiles(notImplementedResolver, emitHost, /*targetSourceFile*/ undefined, /*emitOnlyDtsFiles*/ false, getTransformers(config.options));

return outputFiles;

}

const enum PipelinePhase {

Notification,

Substitution,

Comments,

SourceMaps,

Emit

}

export function createPrinter(printerOptions: PrinterOptions = {}, handlers: PrintHandlers = {}): Printer {

const {

hasGlobalName,

onEmitNode = noEmitNotification,

substituteNode = noEmitSubstitution,

onBeforeEmitNodeArray,

onAfterEmitNodeArray,

onBeforeEmitToken,

onAfterEmitToken

} = handlers;

const extendedDiagnostics = !!printerOptions.extendedDiagnostics;

const newLine = getNewLineCharacter(printerOptions);

const moduleKind = getEmitModuleKind(printerOptions);

const bundledHelpers = createMap<boolean>();

let currentSourceFile: SourceFile | undefined;

let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.

let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.

let generatedNames: Map<true>; // Set of names generated by the NameGenerator.

let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.

let tempFlags: TempFlags; // TempFlags for the current name generation scope.

let reservedNamesStack: Map<true>[]; // Stack of TempFlags reserved in enclosing name generation scopes.

let reservedNames: Map<true>; // TempFlags to reserve in nested name generation scopes.

let writer: EmitTextWriter;

let ownWriter: EmitTextWriter; // Reusable `EmitTextWriter` for basic printing.

let write = writeBase;

let isOwnFileEmit: boolean;

const bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } as BundleFileInfo : undefined;

const recordInternalSection = printerOptions.recordInternalSection;

let sourceFileTextPos = 0;

let sourceFileTextKind: BundleFileTextLikeKind = BundleFileSectionKind.Text;

// Source Maps

let sourceMapsDisabled = true;

let sourceMapGenerator: SourceMapGenerator | undefined;

let sourceMapSource: SourceMapSource;

let sourceMapSourceIndex = -1;

// Comments

let containerPos = -1;

let containerEnd = -1;

let declarationListContainerEnd = -1;

let currentLineMap: ReadonlyArray<number> | undefined;

let detachedCommentsInfo: { nodePos: number, detachedCommentEndPos: number}[] | undefined;

let hasWrittenComment = false;

let commentsDisabled = !!printerOptions.removeComments;

const { enter: enterComment, exit: exitComment } = performance.createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");

reset();

return {

// public API

printNode,

printList,

printFile,

printBundle,

// internal API

writeNode,

writeList,

writeFile,

writeBundle,

bundleFileInfo

};

function printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string {

switch (hint) {

case EmitHint.SourceFile:

Debug.assert(isSourceFile(node), "Expected a SourceFile node.");

break;

case EmitHint.IdentifierName:

Debug.assert(isIdentifier(node), "Expected an Identifier node.");

break;

case EmitHint.Expression:

Debug.assert(isExpression(node), "Expected an Expression node.");

break;

}

switch (node.kind) {

case SyntaxKind.SourceFile: return printFile(<SourceFile>node);

case SyntaxKind.Bundle: return printBundle(<Bundle>node);

case SyntaxKind.UnparsedSource: return printUnparsedSource(<UnparsedSource>node);

}

writeNode(hint, node, sourceFile, beginPrint());

return endPrint();

}

function printList<T extends Node>(format: ListFormat, nodes: NodeArray<T>, sourceFile: SourceFile) {

writeList(format, nodes, sourceFile, beginPrint());

return endPrint();

}

function printBundle(bundle: Bundle): string {

writeBundle(bundle, beginPrint(), /*sourceMapEmitter*/ undefined);

return endPrint();

}

function printFile(sourceFile: SourceFile): string {

writeFile(sourceFile, beginPrint(), /*sourceMapEmitter*/ undefined);

return endPrint();

}

function printUnparsedSource(unparsed: UnparsedSource): string {

writeUnparsedSource(unparsed, beginPrint());

return endPrint();

}

/**

* If `sourceFile` is `undefined`, `node` must be a synthesized `TypeNode`.

*/

function writeNode(hint: EmitHint, node: TypeNode, sourceFile: undefined, output: EmitTextWriter): void;

function writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile, output: EmitTextWriter): void;

function writeNode(hint: EmitHint, node: Node, sourceFile: SourceFile | undefined, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output, /*_sourceMapGenerator*/ undefined);

print(hint, node, sourceFile);

reset();

writer = previousWriter;

}

function writeList<T extends Node>(format: ListFormat, nodes: NodeArray<T>, sourceFile: SourceFile | undefined, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output, /*_sourceMapGenerator*/ undefined);

if (sourceFile) {

setSourceFile(sourceFile);

}

emitList(syntheticParent, nodes, format);

reset();

writer = previousWriter;

}

function getTextPosWithWriteLine() {

return writer.getTextPosWithWriteLine ? writer.getTextPosWithWriteLine() : writer.getTextPos();

}

function updateOrPushBundleFileTextLike(pos: number, end: number, kind: BundleFileTextLikeKind) {

const last = lastOrUndefined(bundleFileInfo!.sections);

if (last && last.kind === kind) {

last.end = end;

}

else {

bundleFileInfo!.sections.push({ pos, end, kind });

}

}

function recordBundleFileInternalSectionStart(node: Node) {

if (recordInternalSection &&

bundleFileInfo &&

currentSourceFile &&

(isDeclaration(node) || isVariableStatement(node)) &&

isInternalDeclaration(node, currentSourceFile) &&

sourceFileTextKind !== BundleFileSectionKind.Internal) {

const prevSourceFileTextKind = sourceFileTextKind;

recordBundleFileTextLikeSection(writer.getTextPos());

sourceFileTextPos = getTextPosWithWriteLine();

sourceFileTextKind = BundleFileSectionKind.Internal;

return prevSourceFileTextKind;

}

return undefined;

}

function recordBundleFileInternalSectionEnd(prevSourceFileTextKind: ReturnType<typeof recordBundleFileInternalSectionStart>) {

if (prevSourceFileTextKind) {

recordBundleFileTextLikeSection(writer.getTextPos());

sourceFileTextPos = getTextPosWithWriteLine();

sourceFileTextKind = prevSourceFileTextKind;

}

}

function recordBundleFileTextLikeSection(end: number) {

if (sourceFileTextPos < end) {

updateOrPushBundleFileTextLike(sourceFileTextPos, end, sourceFileTextKind);

return true;

}

return false;

}

function writeBundle(bundle: Bundle, output: EmitTextWriter, sourceMapGenerator: SourceMapGenerator | undefined) {

isOwnFileEmit = false;

const previousWriter = writer;

setWriter(output, sourceMapGenerator);

emitShebangIfNeeded(bundle);

emitPrologueDirectivesIfNeeded(bundle);

emitHelpers(bundle);

emitSyntheticTripleSlashReferencesIfNeeded(bundle);

for (const prepend of bundle.prepends) {

writeLine();

const pos = writer.getTextPos();

const savedSections = bundleFileInfo && bundleFileInfo.sections;

if (savedSections) bundleFileInfo!.sections = [];

print(EmitHint.Unspecified, prepend, /*sourceFile*/ undefined);

if (bundleFileInfo) {

const newSections = bundleFileInfo.sections;

bundleFileInfo.sections = savedSections!;

if (prepend.oldFileOfCurrentEmit) bundleFileInfo.sections.push(...newSections);

else {

newSections.forEach(section => Debug.assert(isBundleFileTextLike(section)));

bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: BundleFileSectionKind.Prepend, data: (prepend as UnparsedSource).fileName, texts: newSections as BundleFileTextLike[] });

}

}

}

sourceFileTextPos = getTextPosWithWriteLine();

for (const sourceFile of bundle.sourceFiles) {

print(EmitHint.SourceFile, sourceFile, sourceFile);

}

if (bundleFileInfo && bundle.sourceFiles.length) {

const end = writer.getTextPos();

if (recordBundleFileTextLikeSection(end)) {

// Store prologues

const prologues = getPrologueDirectivesFromBundledSourceFiles(bundle);

if (prologues) {

if (!bundleFileInfo.sources) bundleFileInfo.sources = {};

bundleFileInfo.sources.prologues = prologues;

}

// Store helpes

const helpers = getHelpersFromBundledSourceFiles(bundle);

if (helpers) {

if (!bundleFileInfo.sources) bundleFileInfo.sources = {};

bundleFileInfo.sources.helpers = helpers;

}

}

}

reset();

writer = previousWriter;

}

function writeUnparsedSource(unparsed: UnparsedSource, output: EmitTextWriter) {

const previousWriter = writer;

setWriter(output, /*_sourceMapGenerator*/ undefined);

print(EmitHint.Unspecified, unparsed, /*sourceFile*/ undefined);

reset();

writer = previousWriter;

}

function writeFile(sourceFile: SourceFile, output: EmitTextWriter, sourceMapGenerator: SourceMapGenerator | undefined) {

isOwnFileEmit = true;

const previousWriter = writer;

setWriter(output, sourceMapGenerator);

emitShebangIfNeeded(sourceFile);

emitPrologueDirectivesIfNeeded(sourceFile);

print(EmitHint.SourceFile, sourceFile, sourceFile);

reset();

writer = previousWriter;

}

function beginPrint() {

return ownWriter || (ownWriter = createTextWriter(newLine));

}

function endPrint() {

const text = ownWriter.getText();

ownWriter.clear();

return text;

}

function print(hint: EmitHint, node: Node, sourceFile: SourceFile | undefined) {

if (sourceFile) {

setSourceFile(sourceFile);

}