interface EmitTextWriter {

write(s: string): void;

writeLine(): void;

increaseIndent(): void;

decreaseIndent(): void;

getText(): string;

rawWrite(s: string): void;

writeLiteral(s: string): void;

getTextPos(): number;

getLine(): number;

getColumn(): number;

getIndent(): number;

}

interface EmitTextWriterWithSymbolWriter extends EmitTextWriter, SymbolWriter{

}

var indentStrings: string[] = ["", " "];

export function getIndentString(level: number) {

if (indentStrings[level] === undefined) {

indentStrings[level] = getIndentString(level - 1) + indentStrings[1];

}

return indentStrings[level];

}

function getIndentSize() {

return indentStrings[1].length;

}

export function shouldEmitToOwnFile(sourceFile: SourceFile, compilerOptions: CompilerOptions): boolean {

if (!isDeclarationFile(sourceFile)) {

if ((isExternalModule(sourceFile) || !compilerOptions.out) && !fileExtensionIs(sourceFile.filename, ".js")) {

return true;

}

return false;

}

return false;

}

export function isExternalModuleOrDeclarationFile(sourceFile: SourceFile) {

return isExternalModule(sourceFile) || isDeclarationFile(sourceFile);

}

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

export function emitFiles(resolver: EmitResolver, targetSourceFile?: SourceFile): EmitResult {

var program = resolver.getProgram();

var compilerHost = program.getCompilerHost();

var compilerOptions = program.getCompilerOptions();

var sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap ? [] : undefined;

var diagnostics: Diagnostic[] = [];

var newLine = program.getCompilerHost().getNewLine();

function getSourceFilePathInNewDir(newDirPath: string, sourceFile: SourceFile) {

var sourceFilePath = getNormalizedAbsolutePath(sourceFile.filename, compilerHost.getCurrentDirectory());

sourceFilePath = sourceFilePath.replace(program.getCommonSourceDirectory(), "");

return combinePaths(newDirPath, sourceFilePath);

}

function getOwnEmitOutputFilePath(sourceFile: SourceFile, extension: string) {

if (compilerOptions.outDir) {

var emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(compilerOptions.outDir, sourceFile));

}

else {

var emitOutputFilePathWithoutExtension = removeFileExtension(sourceFile.filename);

}

return emitOutputFilePathWithoutExtension + extension;

}

function getFirstConstructorWithBody(node: ClassDeclaration): ConstructorDeclaration {

return forEach(node.members, member => {

if (member.kind === SyntaxKind.Constructor && (<ConstructorDeclaration>member).body) {

return <ConstructorDeclaration>member;

}

});

}

function getAllAccessorDeclarations(node: ClassDeclaration, accessor: AccessorDeclaration) {

var firstAccessor: AccessorDeclaration;

var getAccessor: AccessorDeclaration;

var setAccessor: AccessorDeclaration;

forEach(node.members, (member: Declaration) => {

// TODO(jfreeman): Handle computed names for accessor matching

if ((member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) &&

(<Identifier>member.name).text === (<Identifier>accessor.name).text &&

(member.flags & NodeFlags.Static) === (accessor.flags & NodeFlags.Static)) {

if (!firstAccessor) {

firstAccessor = <AccessorDeclaration>member;

}

if (member.kind === SyntaxKind.GetAccessor && !getAccessor) {

getAccessor = <AccessorDeclaration>member;

}

if (member.kind === SyntaxKind.SetAccessor && !setAccessor) {

setAccessor = <AccessorDeclaration>member;

}

}

});

return {

firstAccessor,

getAccessor,

setAccessor

};

}

function createTextWriter(): EmitTextWriter {

var output = "";

var indent = 0;

var lineStart = true;

var lineCount = 0;

var linePos = 0;

function write(s: string) {

if (s && s.length) {

if (lineStart) {

output += getIndentString(indent);

lineStart = false;

}

output += s;

}

}

function rawWrite(s: string) {

if (s !== undefined) {

if (lineStart) {

lineStart = false;

}

output += s;

}

}

function writeLiteral(s: string) {

if (s && s.length) {

write(s);

var lineStartsOfS = computeLineStarts(s);

if (lineStartsOfS.length > 1) {

lineCount = lineCount + lineStartsOfS.length - 1;

linePos = output.length - s.length + lineStartsOfS[lineStartsOfS.length - 1];

}

}

}

function writeLine() {

if (!lineStart) {

output += newLine;

lineCount++;

linePos = output.length;

lineStart = true;

}

}

return {

write: write,

rawWrite: rawWrite,

writeLiteral: writeLiteral,

writeLine: writeLine,

increaseIndent: () => indent++,

decreaseIndent: () => indent--,

getIndent: () => indent,

getTextPos: () => output.length,

getLine: () => lineCount + 1,

getColumn: () => lineStart ? indent * getIndentSize() + 1 : output.length - linePos + 1,

getText: () => output,

};

}

// Get source text of node in the current source file. Unlike getSourceTextOfNode this function

// doesn't walk the parent chain to find the containing source file, rather it assumes the node is

// in the source file currently being processed.

var currentSourceFile: SourceFile;

function getSourceTextOfLocalNode(node: Node): string {

var text = currentSourceFile.text;

return text.substring(skipTrivia(text, node.pos), node.end);

}

function getLineOfLocalPosition(pos: number) {

return currentSourceFile.getLineAndCharacterFromPosition(pos).line;

}

function writeFile(filename: string, data: string, writeByteOrderMark: boolean) {

compilerHost.writeFile(filename, data, writeByteOrderMark, hostErrorMessage => {

diagnostics.push(createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, filename, hostErrorMessage));

});

}

function emitComments(comments: CommentRange[], trailingSeparator: boolean, writer: EmitTextWriter, writeComment: (comment: CommentRange, writer: EmitTextWriter) => void) {

var emitLeadingSpace = !trailingSeparator;

forEach(comments, comment => {

if (emitLeadingSpace) {

writer.write(" ");

emitLeadingSpace = false;

}

writeComment(comment, writer);

if (comment.hasTrailingNewLine) {

writer.writeLine();

}

else if (trailingSeparator) {

writer.write(" ");

}

else {

// Emit leading space to separate comment during next comment emit

emitLeadingSpace = true;

}

});

}

function emitNewLineBeforeLeadingComments(node: TextRange, leadingComments: CommentRange[], writer: EmitTextWriter) {

// If the leading comments start on different line than the start of node, write new line

if (leadingComments && leadingComments.length && node.pos !== leadingComments[0].pos &&

getLineOfLocalPosition(node.pos) !== getLineOfLocalPosition(leadingComments[0].pos)) {

writer.writeLine();

}

}

function writeCommentRange(comment: CommentRange, writer: EmitTextWriter) {

if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk) {

var firstCommentLineAndCharacter = currentSourceFile.getLineAndCharacterFromPosition(comment.pos);

var firstCommentLineIndent: number;

for (var pos = comment.pos, currentLine = firstCommentLineAndCharacter.line; pos < comment.end; currentLine++) {

var nextLineStart = currentSourceFile.getPositionFromLineAndCharacter(currentLine + 1, /*character*/1);

if (pos !== comment.pos) {

// If we are not emitting first line, we need to write the spaces to adjust the alignment

if (firstCommentLineIndent === undefined) {

firstCommentLineIndent = calculateIndent(currentSourceFile.getPositionFromLineAndCharacter(firstCommentLineAndCharacter.line, /*character*/1),

comment.pos);

}

// These are number of spaces writer is going to write at current indent

var currentWriterIndentSpacing = writer.getIndent() * getIndentSize();

// Number of spaces we want to be writing

// eg: Assume writer indent

// module m {

// /* starts at character 9 this is line 1

// * starts at character pos 4 line --1 = 8 - 8 + 3

// More left indented comment */ --2 = 8 - 8 + 2

// class c { }

// }

// module m {

// /* this is line 1 -- Assume current writer indent 8

// * line --3 = 8 - 4 + 5

// More right indented comment */ --4 = 8 - 4 + 11

// class c { }

// }

var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(pos, nextLineStart);

if (spacesToEmit > 0) {

var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();

var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());

// Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces

writer.rawWrite(indentSizeSpaceString);

// Emit the single spaces (in eg: 1: 3 spaces, 2: 2 spaces, 3: 1 space, 4: 3 spaces)

while (numberOfSingleSpacesToEmit) {

writer.rawWrite(" ");

numberOfSingleSpacesToEmit--;

}

}

else {

// No spaces to emit write empty string

writer.rawWrite("");

}

}

// Write the comment line text

writeTrimmedCurrentLine(pos, nextLineStart);

pos = nextLineStart;

}

}

else {

// Single line comment of style //....

writer.write(currentSourceFile.text.substring(comment.pos, comment.end));

}

function writeTrimmedCurrentLine(pos: number, nextLineStart: number) {

var end = Math.min(comment.end, nextLineStart - 1);

var currentLineText = currentSourceFile.text.substring(pos, end).replace(/^\s+|\s+$/g, '');

if (currentLineText) {

// trimmed forward and ending spaces text

writer.write(currentLineText);

if (end !== comment.end) {

writer.writeLine();

}

}

else {

// Empty string - make sure we write empty line

writer.writeLiteral(newLine);

}

}

function calculateIndent(pos: number, end: number) {

var currentLineIndent = 0;

for (; pos < end && isWhiteSpace(currentSourceFile.text.charCodeAt(pos)); pos++) {

if (currentSourceFile.text.charCodeAt(pos) === CharacterCodes.tab) {

// Tabs = TabSize = indent size and go to next tabStop

currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize());

}

else {

// Single space

currentLineIndent++;

}

}

return currentLineIndent;

}

}

function emitJavaScript(jsFilePath: string, root?: SourceFile) {

var writer = createTextWriter();

var write = writer.write;

var writeLine = writer.writeLine;

var increaseIndent = writer.increaseIndent;

var decreaseIndent = writer.decreaseIndent;

var extendsEmitted = false;

/** write emitted output to disk*/

var writeEmittedFiles = writeJavaScriptFile;

/** Emit leading comments of the node */

var emitLeadingComments = compilerOptions.removeComments ? (node: Node) => { } : emitLeadingDeclarationComments;

/** Emit Trailing comments of the node */

var emitTrailingComments = compilerOptions.removeComments ? (node: Node) => { } : emitTrailingDeclarationComments;

var emitLeadingCommentsOfPosition = compilerOptions.removeComments ? (pos: number) => { } : emitLeadingCommentsOfLocalPosition;

var detachedCommentsInfo: { nodePos: number; detachedCommentEndPos: number }[];

/** Emit detached comments of the node */

var emitDetachedComments = compilerOptions.removeComments ? (node: TextRange) => { } : emitDetachedCommentsAtPosition;

/** Emits /// or pinned which is comment starting with /*! comments */

var emitPinnedOrTripleSlashComments = compilerOptions.removeComments ? (node: Node) => { } : emitPinnedOrTripleSlashCommentsOfNode;

var writeComment = writeCommentRange;

/** Emit a node */

var emit = emitNode;

/** Called just before starting emit of a node */

var emitStart = function (node: Node) { };

/** Called once the emit of the node is done */

var emitEnd = function (node: Node) { };

/** Emit the text for the given token that comes after startPos

var emitToken = emitTokenText;

/** Called to before starting the lexical scopes as in function/class in the emitted code because of node

var scopeEmitStart = function (scopeDeclaration: Node, scopeName?: string) { }

/** Called after coming out of the scope */

var scopeEmitEnd = function () { }

/** Sourcemap data that will get encoded */

var sourceMapData: SourceMapData;

function initializeEmitterWithSourceMaps() {

var sourceMapDir: string; // The directory in which sourcemap will be

// Current source map file and its index in the sources list

var sourceMapSourceIndex = -1;

// Names and its index map

var sourceMapNameIndexMap: Map<number> = {};

var sourceMapNameIndices: number[] = [];

function getSourceMapNameIndex() {

return sourceMapNameIndices.length ? sourceMapNameIndices[sourceMapNameIndices.length - 1] : -1;

}

// Last recorded and encoded spans

var lastRecordedSourceMapSpan: SourceMapSpan;

var lastEncodedSourceMapSpan: SourceMapSpan = {

emittedLine: 1,

emittedColumn: 1,

sourceLine: 1,

sourceColumn: 1,

sourceIndex: 0

};

var lastEncodedNameIndex = 0;

// Encoding for sourcemap span

function encodeLastRecordedSourceMapSpan() {

if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) {

return;

}

var prevEncodedEmittedColumn = lastEncodedSourceMapSpan.emittedColumn;

// Line/Comma delimiters

if (lastEncodedSourceMapSpan.emittedLine == lastRecordedSourceMapSpan.emittedLine) {

// Emit comma to separate the entry

if (sourceMapData.sourceMapMappings) {

sourceMapData.sourceMapMappings += ",";

}

}

else {

// Emit line delimiters

for (var encodedLine = lastEncodedSourceMapSpan.emittedLine; encodedLine < lastRecordedSourceMapSpan.emittedLine; encodedLine++) {

sourceMapData.sourceMapMappings += ";";

}

prevEncodedEmittedColumn = 1;

}

// 1. Relative Column 0 based

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.emittedColumn - prevEncodedEmittedColumn);

// 2. Relative sourceIndex

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceIndex - lastEncodedSourceMapSpan.sourceIndex);

// 3. Relative sourceLine 0 based

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceLine - lastEncodedSourceMapSpan.sourceLine);

// 4. Relative sourceColumn 0 based

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.sourceColumn - lastEncodedSourceMapSpan.sourceColumn);

// 5. Relative namePosition 0 based

if (lastRecordedSourceMapSpan.nameIndex >= 0) {

sourceMapData.sourceMapMappings += base64VLQFormatEncode(lastRecordedSourceMapSpan.nameIndex - lastEncodedNameIndex);

lastEncodedNameIndex = lastRecordedSourceMapSpan.nameIndex;

}

lastEncodedSourceMapSpan = lastRecordedSourceMapSpan;

sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan);

function base64VLQFormatEncode(inValue: number) {

function base64FormatEncode(inValue: number) {

if (inValue < 64) {

return 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.charAt(inValue);

}

throw TypeError(inValue + ": not a 64 based value");

}

// Add a new least significant bit that has the sign of the value.

// if negative number the least significant bit that gets added to the number has value 1

// else least significant bit value that gets added is 0

// eg. -1 changes to binary : 01 [1] => 3

// +1 changes to binary : 01 [0] => 2

if (inValue < 0) {

inValue = ((-inValue) << 1) + 1;

}

else {

inValue = inValue << 1;

}

// Encode 5 bits at a time starting from least significant bits

var encodedStr = "";

do {

var currentDigit = inValue & 31; // 11111

inValue = inValue >> 5;

if (inValue > 0) {

// There are still more digits to decode, set the msb (6th bit)

currentDigit = currentDigit | 32;

}

encodedStr = encodedStr + base64FormatEncode(currentDigit);

} while (inValue > 0);

return encodedStr;

}

}

function recordSourceMapSpan(pos: number) {

var sourceLinePos = currentSourceFile.getLineAndCharacterFromPosition(pos);

var emittedLine = writer.getLine();

var emittedColumn = writer.getColumn();

// If this location wasn't recorded or the location in source is going backwards, record the span

if (!lastRecordedSourceMapSpan ||

lastRecordedSourceMapSpan.emittedLine != emittedLine ||

lastRecordedSourceMapSpan.emittedColumn != emittedColumn ||

(lastRecordedSourceMapSpan.sourceIndex === sourceMapSourceIndex &&

(lastRecordedSourceMapSpan.sourceLine > sourceLinePos.line ||

(lastRecordedSourceMapSpan.sourceLine === sourceLinePos.line && lastRecordedSourceMapSpan.sourceColumn > sourceLinePos.character)))) {

// Encode the last recordedSpan before assigning new

encodeLastRecordedSourceMapSpan();

// New span

lastRecordedSourceMapSpan = {

emittedLine: emittedLine,

emittedColumn: emittedColumn,

sourceLine: sourceLinePos.line,

sourceColumn: sourceLinePos.character,

nameIndex: getSourceMapNameIndex(),

sourceIndex: sourceMapSourceIndex

};

}

else {

// Take the new pos instead since there is no change in emittedLine and column since last location

lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line;

lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character;

lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex;

}

}

function recordEmitNodeStartSpan(node: Node) {

// Get the token pos after skipping to the token (ignoring the leading trivia)

recordSourceMapSpan(skipTrivia(currentSourceFile.text, node.pos));

}

function recordEmitNodeEndSpan(node: Node) {

recordSourceMapSpan(node.end);

}

function writeTextWithSpanRecord(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {

var tokenStartPos = ts.skipTrivia(currentSourceFile.text, startPos);

recordSourceMapSpan(tokenStartPos);

var tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn);

recordSourceMapSpan(tokenEndPos);

return tokenEndPos;

}

function recordNewSourceFileStart(node: SourceFile) {

// Add the file to tsFilePaths

// If sourceroot option: Use the relative path corresponding to the common directory path

// otherwise source locations relative to map file location

var sourcesDirectoryPath = compilerOptions.sourceRoot ? program.getCommonSourceDirectory() : sourceMapDir;

sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,

node.filename,

compilerHost.getCurrentDirectory(),

compilerHost.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true));

sourceMapSourceIndex = sourceMapData.sourceMapSources.length - 1;

// The one that can be used from program to get the actual source file

sourceMapData.inputSourceFileNames.push(node.filename);

}

function recordScopeNameOfNode(node: Node, scopeName?: string) {

function recordScopeNameIndex(scopeNameIndex: number) {

sourceMapNameIndices.push(scopeNameIndex);

}

function recordScopeNameStart(scopeName: string) {

var scopeNameIndex = -1;

if (scopeName) {

var parentIndex = getSourceMapNameIndex();

if (parentIndex !== -1) {

scopeName = sourceMapData.sourceMapNames[parentIndex] + "." + scopeName;

}

scopeNameIndex = getProperty(sourceMapNameIndexMap, scopeName);

if (scopeNameIndex === undefined) {

scopeNameIndex = sourceMapData.sourceMapNames.length;

sourceMapData.sourceMapNames.push(scopeName);

sourceMapNameIndexMap[scopeName] = scopeNameIndex;

}

}

recordScopeNameIndex(scopeNameIndex);

}

if (scopeName) {

// The scope was already given a name use it

recordScopeNameStart(scopeName);

}

else if (node.kind === SyntaxKind.FunctionDeclaration ||

node.kind === SyntaxKind.FunctionExpression ||

node.kind === SyntaxKind.Method ||

node.kind === SyntaxKind.GetAccessor ||

node.kind === SyntaxKind.SetAccessor ||

node.kind === SyntaxKind.ModuleDeclaration ||

node.kind === SyntaxKind.ClassDeclaration ||

node.kind === SyntaxKind.EnumDeclaration) {

// Declaration and has associated name use it

if ((<Declaration>node).name) {

// TODO(jfreeman): Ask shkamat about what this name should be for source maps

scopeName = (<Identifier>(<Declaration>node).name).text;

}

recordScopeNameStart(scopeName);

}

else {

// Block just use the name from upper level scope

recordScopeNameIndex(getSourceMapNameIndex());

}

}

function recordScopeNameEnd() {

sourceMapNameIndices.pop();

};

function writeCommentRangeWithMap(comment: CommentRange, writer: EmitTextWriter) {

recordSourceMapSpan(comment.pos);

writeCommentRange(comment, writer);

recordSourceMapSpan(comment.end);

}

function serializeSourceMapContents(version: number, file: string, sourceRoot: string, sources: string[], names: string[], mappings: string) {

if (typeof JSON !== "undefined") {

return JSON.stringify({

version: version,

file: file,

sourceRoot: sourceRoot,

sources: sources,

names: names,

mappings: mappings

});

}

return "{\"version\":" + version + ",\"file\":\"" + escapeString(file) + "\",\"sourceRoot\":\"" + escapeString(sourceRoot) + "\",\"sources\":[" + serializeStringArray(sources) + "],\"names\":[" + serializeStringArray(names) + "],\"mappings\":\"" + escapeString(mappings) + "\"}";

function serializeStringArray(list: string[]): string {

var output = "";

for (var i = 0, n = list.length; i < n; i++) {

if (i) {

output += ",";

}

output += "\"" + escapeString(list[i]) + "\"";

}

return output;

}

}

function writeJavaScriptAndSourceMapFile(emitOutput: string, writeByteOrderMark: boolean) {

// Write source map file

encodeLastRecordedSourceMapSpan();

writeFile(sourceMapData.sourceMapFilePath, serializeSourceMapContents(

3,

sourceMapData.sourceMapFile,

sourceMapData.sourceMapSourceRoot,

sourceMapData.sourceMapSources,

sourceMapData.sourceMapNames,

sourceMapData.sourceMapMappings), /*writeByteOrderMark*/ false);

sourceMapDataList.push(sourceMapData);

// Write sourcemap url to the js file and write the js file

writeJavaScriptFile(emitOutput + "//# sourceMappingURL=" + sourceMapData.jsSourceMappingURL, writeByteOrderMark);

}

// Initialize source map data

var sourceMapJsFile = getBaseFilename(normalizeSlashes(jsFilePath));

sourceMapData = {

sourceMapFilePath: jsFilePath + ".map",

jsSourceMappingURL: sourceMapJsFile + ".map",

sourceMapFile: sourceMapJsFile,

sourceMapSourceRoot: compilerOptions.sourceRoot || "",

sourceMapSources: [],

inputSourceFileNames: [],

sourceMapNames: [],

sourceMapMappings: "",

sourceMapDecodedMappings: []

};

// 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

sourceMapData.sourceMapSourceRoot = ts.normalizeSlashes(sourceMapData.sourceMapSourceRoot);

if (sourceMapData.sourceMapSourceRoot.length && sourceMapData.sourceMapSourceRoot.charCodeAt(sourceMapData.sourceMapSourceRoot.length - 1) !== CharacterCodes.slash) {

sourceMapData.sourceMapSourceRoot += directorySeparator;

}

if (compilerOptions.mapRoot) {

sourceMapDir = normalizeSlashes(compilerOptions.mapRoot);

if (root) { // emitting single module file

// 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(sourceMapDir, root));

}

if (!isRootedDiskPath(sourceMapDir) && !isUrl(sourceMapDir)) {

// The relative paths are relative to the common directory

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

sourceMapData.jsSourceMappingURL = getRelativePathToDirectoryOrUrl(

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

combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), // this is where user expects to see sourceMap

compilerHost.getCurrentDirectory(),

compilerHost.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true);

}

else {

sourceMapData.jsSourceMappingURL = combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL);

}

}

else {

sourceMapDir = getDirectoryPath(normalizePath(jsFilePath));

}

function emitNodeWithMap(node: Node) {

if (node) {

if (node.kind != SyntaxKind.SourceFile) {

recordEmitNodeStartSpan(node);

emitNode(node);

recordEmitNodeEndSpan(node);

}

else {

recordNewSourceFileStart(<SourceFile>node);

emitNode(node);

}

}

}

writeEmittedFiles = writeJavaScriptAndSourceMapFile;

emit = emitNodeWithMap;

emitStart = recordEmitNodeStartSpan;

emitEnd = recordEmitNodeEndSpan;

emitToken = writeTextWithSpanRecord;

scopeEmitStart = recordScopeNameOfNode;

scopeEmitEnd = recordScopeNameEnd;

writeComment = writeCommentRangeWithMap;

}

function writeJavaScriptFile(emitOutput: string, writeByteOrderMark: boolean) {

writeFile(jsFilePath, emitOutput, writeByteOrderMark);

}

function emitTokenText(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {

var tokenString = tokenToString(tokenKind);

if (emitFn) {

emitFn();

}

else {

write(tokenString);

}

return startPos + tokenString.length;

}

function emitOptional(prefix: string, node: Node) {

if (node) {

write(prefix);

emit(node);

}

}

function emitTrailingCommaIfPresent(nodeList: NodeArray<Node>, isMultiline: boolean): void {

if (nodeList.hasTrailingComma) {

write(",");

if (isMultiline) {

writeLine();

}

}

}

function emitCommaList(nodes: NodeArray<Node>, includeTrailingComma: boolean, count?: number) {

if (!(count >= 0)) {

count = nodes.length;

}

if (nodes) {

for (var i = 0; i < count; i++) {

if (i) {

write(", ");

}

emit(nodes[i]);

}

if (includeTrailingComma) {

emitTrailingCommaIfPresent(nodes, /*isMultiline*/ false);

}

}

}

function emitMultiLineList(nodes: NodeArray<Node>, includeTrailingComma: boolean) {

if (nodes) {

for (var i = 0; i < nodes.length; i++) {

if (i) {

write(",");

}

writeLine();

emit(nodes[i]);

}

if (includeTrailingComma) {

emitTrailingCommaIfPresent(nodes, /*isMultiline*/ true);

}

}

}

function emitLines(nodes: Node[]) {

emitLinesStartingAt(nodes, /*startIndex*/ 0);

}

function emitLinesStartingAt(nodes: Node[], startIndex: number): void {

for (var i = startIndex; i < nodes.length; i++) {

writeLine();

emit(nodes[i]);

}

}

function emitLiteral(node: LiteralExpression): void {

var text = getLiteralText();

if (compilerOptions.sourceMap && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {

writer.writeLiteral(text);

}

else {

write(text);

}

function getLiteralText() {

if (compilerOptions.target < ScriptTarget.ES6 && isTemplateLiteralKind(node.kind)) {

return getTemplateLiteralAsStringLiteral(node)

}

return getSourceTextOfLocalNode(node);

}

}

function getTemplateLiteralAsStringLiteral(node: LiteralExpression): string {

return '"' + escapeString(node.text) + '"';

}

function emitTemplateExpression(node: TemplateExpression): void {

// In ES6 mode and above, we can simply emit each portion of a template in order, but in

// ES3 & ES5 we must convert the template expression into a series of string concatenations.

if (compilerOptions.target >= ScriptTarget.ES6) {

forEachChild(node, emit);

return;

}

Debug.assert(node.parent.kind !== SyntaxKind.TaggedTemplateExpression);

var templateNeedsParens = isExpression(node.parent)

&& node.parent.kind !== SyntaxKind.ParenExpression

&& comparePrecedenceToBinaryPlus(node.parent) !== Comparison.LessThan;

if (templateNeedsParens) {

write("(");

}

emitLiteral(node.head);