Auto = 0x00000000, // No preferred name

CountMask = 0x0FFFFFFF, // Temp variable counter

_i = 0x10000000, // Use/preference flag for '_i'

// emit output for the __extends helper function

const extendsHelper = `

// emit output for the __decorate helper function

const decorateHelper = `

// emit output for the __metadata helper function

const metadataHelper = `

// emit output for the __param helper function

const paramHelper = `

let compilerOptions = host.getCompilerOptions();

let languageVersion = compilerOptions.target || ScriptTarget.ES3;

let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;

let diagnostics: Diagnostic[] = [];

let newLine = host.getNewLine();

if (targetSourceFile === undefined) {

forEach(host.getSourceFiles(), sourceFile => {

if (shouldEmitToOwnFile(sourceFile, compilerOptions)) {

let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host, ".js");

emitFile(jsFilePath, sourceFile);

}

});

if (compilerOptions.out) {

emitFile(compilerOptions.out);

}

}

else {

// targetSourceFile is specified (e.g calling emitter from language service or calling getSemanticDiagnostic from language service)

if (shouldEmitToOwnFile(targetSourceFile, compilerOptions)) {

let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js");

emitFile(jsFilePath, targetSourceFile);

}

else if (!isDeclarationFile(targetSourceFile) && compilerOptions.out) {

emitFile(compilerOptions.out);

}

}

// Sort and make the unique list of diagnostics

diagnostics = sortAndDeduplicateDiagnostics(diagnostics);

return {

emitSkipped: false,

diagnostics,

sourceMaps: sourceMapDataList

};

function isNodeDescendentOf(node: Node, ancestor: Node): boolean {

while (node) {

if (node === ancestor) return true;

node = node.parent;

}

return false;

}

function isUniqueLocalName(name: string, container: Node): boolean {

for (let node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {

if (node.locals && hasProperty(node.locals, name)) {

// We conservatively include alias symbols to cover cases where they're emitted as locals

if (node.locals[name].flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {

return false;

}

}

}

return true;

}

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

let writer = createTextWriter(newLine);

let write = writer.write;

let writeTextOfNode = writer.writeTextOfNode;

let writeLine = writer.writeLine;

let increaseIndent = writer.increaseIndent;

let decreaseIndent = writer.decreaseIndent;

let currentSourceFile: SourceFile;

// name of an exporter function if file is a System external module

// System.register([...], function (<exporter>) {...})

// exporting in System modules looks like:

// export var x; ... x = 1

// =>

// var x;... exporter("x", x = 1)

let exportFunctionForFile: string;

let generatedNameSet: Map<string> = {};

let nodeToGeneratedName: string[] = [];

let computedPropertyNamesToGeneratedNames: string[];

let extendsEmitted = false;

let decorateEmitted = false;

let paramEmitted = false;

let tempFlags = 0;

let tempVariables: Identifier[];

let tempParameters: Identifier[];

let externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[];

let exportSpecifiers: Map<ExportSpecifier[]>;

let exportEquals: ExportAssignment;

let hasExportStars: boolean;

/** Write emitted output to disk */

let writeEmittedFiles = writeJavaScriptFile;

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

let writeComment = writeCommentRange;

/** Emit a node */

let emit = emitNodeWithoutSourceMap;

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

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

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

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

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

let emitToken = emitTokenText;

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

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

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

let scopeEmitEnd = function () { }

/** Sourcemap data that will get encoded */

let sourceMapData: SourceMapData;

if (compilerOptions.sourceMap || compilerOptions.inlineSourceMap) {

initializeEmitterWithSourceMaps();

}

if (root) {

// Do not call emit directly. It does not set the currentSourceFile.

emitSourceFile(root);

}

else {

forEach(host.getSourceFiles(), sourceFile => {

if (!isExternalModuleOrDeclarationFile(sourceFile)) {

emitSourceFile(sourceFile);

}

});

}

writeLine();

writeEmittedFiles(writer.getText(), /*writeByteOrderMark*/ compilerOptions.emitBOM);

return;

function emitSourceFile(sourceFile: SourceFile): void {

currentSourceFile = sourceFile;

exportFunctionForFile = undefined;

emit(sourceFile);

}

function isUniqueName(name: string): boolean {

return !resolver.hasGlobalName(name) &&

!hasProperty(currentSourceFile.identifiers, name) &&

!hasProperty(generatedNameSet, name);

}

// Return the next available name in the pattern _a ... _z, _0, _1, ...

// TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name.

// Note that names generated by makeTempVariableName and makeUniqueName will never conflict.

function makeTempVariableName(flags: TempFlags): string {

if (flags && !(tempFlags & flags)) {

var name = flags === TempFlags._i ? "_i" : "_n"

if (isUniqueName(name)) {

tempFlags |= flags;

return name;

}

}

while (true) {

let count = tempFlags & TempFlags.CountMask;

tempFlags++;

// Skip over 'i' and 'n'

if (count !== 8 && count !== 13) {

let name = count < 26 ? "_" + String.fromCharCode(CharacterCodes.a + count) : "_" + (count - 26);

if (isUniqueName(name)) {

return name;

}

}

}

}

// Generate a name that is unique within the current file and doesn't conflict with any names

// in global scope. The name is formed by adding an '_n' suffix to the specified base name,

// where n is a positive integer. Note that names generated by makeTempVariableName and

// makeUniqueName are guaranteed to never conflict.

function makeUniqueName(baseName: string): string {

// Find the first unique 'name_n', where n is a positive number

if (baseName.charCodeAt(baseName.length - 1) !== CharacterCodes._) {

baseName += "_";

}

let i = 1;

while (true) {

let generatedName = baseName + i;

if (isUniqueName(generatedName)) {

return generatedNameSet[generatedName] = generatedName;

}

i++;

}

}

function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {

let name = node.name.text;

// Use module/enum name itself if it is unique, otherwise make a unique variation

return isUniqueLocalName(name, node) ? name : makeUniqueName(name);

}

function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {

let expr = getExternalModuleName(node);

let baseName = expr.kind === SyntaxKind.StringLiteral ?

escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";

return makeUniqueName(baseName);

}

function generateNameForExportDefault() {

return makeUniqueName("default");

}

function generateNameForClassExpression() {

return makeUniqueName("class");

}

function generateNameForNode(node: Node) {

switch (node.kind) {

case SyntaxKind.Identifier:

return makeUniqueName((<Identifier>node).text);

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.EnumDeclaration:

return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node);

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ExportDeclaration:

return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ExportAssignment:

return generateNameForExportDefault();

case SyntaxKind.ClassExpression:

return generateNameForClassExpression();

}

}

function getGeneratedNameForNode(node: Node) {

let id = getNodeId(node);

return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = unescapeIdentifier(generateNameForNode(node)));

}

function initializeEmitterWithSourceMaps() {

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

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

let sourceMapSourceIndex = -1;

// Names and its index map

let sourceMapNameIndexMap: Map<number> = {};

let sourceMapNameIndices: number[] = [];

function getSourceMapNameIndex() {

return sourceMapNameIndices.length ? lastOrUndefined(sourceMapNameIndices) : -1;

}

// Last recorded and encoded spans

let lastRecordedSourceMapSpan: SourceMapSpan;

let lastEncodedSourceMapSpan: SourceMapSpan = {

emittedLine: 1,

emittedColumn: 1,

sourceLine: 1,

sourceColumn: 1,

sourceIndex: 0

};

let lastEncodedNameIndex = 0;

// Encoding for sourcemap span

function encodeLastRecordedSourceMapSpan() {

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

return;

}

let 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 (let 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

let encodedStr = "";

do {

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

let sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos);

// Convert the location to be one-based.

sourceLinePos.line++;

sourceLinePos.character++;

let emittedLine = writer.getLine();

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

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

recordSourceMapSpan(tokenStartPos);

let 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

let sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;

sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,

node.fileName,

host.getCurrentDirectory(),

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

if (compilerOptions.inlineSources) {

if (!sourceMapData.sourceMapSourcesContent) {

sourceMapData.sourceMapSourcesContent = [];

}

sourceMapData.sourceMapSourcesContent.push(node.text);

}

}

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

function recordScopeNameIndex(scopeNameIndex: number) {

sourceMapNameIndices.push(scopeNameIndex);

}

function recordScopeNameStart(scopeName: string) {

let scopeNameIndex = -1;

if (scopeName) {

let parentIndex = getSourceMapNameIndex();

if (parentIndex !== -1) {

// Child scopes are always shown with a dot (even if they have no name),

// unless it is a computed property. Then it is shown with brackets,

// but the brackets are included in the name.

let name = (<Declaration>node).name;

if (!name || name.kind !== SyntaxKind.ComputedPropertyName) {

scopeName = "." + scopeName;

}

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.MethodDeclaration ||

node.kind === SyntaxKind.MethodSignature ||

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

let name = (<Declaration>node).name;

// For computed property names, the text will include the brackets

scopeName = name.kind === SyntaxKind.ComputedPropertyName

? getTextOfNode(name)

: (<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(curentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) {

recordSourceMapSpan(comment.pos);

writeCommentRange(currentSourceFile, writer, comment, newLine);

recordSourceMapSpan(comment.end);

}

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

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

let map: any = {

version,

file,

sourceRoot,

sources,

names,

mappings

};

if (sourcesContent !== undefined) {

map.sourcesContent = sourcesContent;

}

return JSON.stringify(map);

}

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

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

let output = "";

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

if (i) {

output += ",";

}

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

}

return output;

}

}

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

encodeLastRecordedSourceMapSpan();

let sourceMapText = serializeSourceMapContents(

3,

sourceMapData.sourceMapFile,

sourceMapData.sourceMapSourceRoot,

sourceMapData.sourceMapSources,

sourceMapData.sourceMapNames,

sourceMapData.sourceMapMappings,

sourceMapData.sourceMapSourcesContent);

sourceMapDataList.push(sourceMapData);

let sourceMapUrl: string;

if (compilerOptions.inlineSourceMap) {

// Encode the sourceMap into the sourceMap url

let base64SourceMapText = convertToBase64(sourceMapText);

sourceMapUrl = `//# sourceMappingURL=data:application/json;base64,${base64SourceMapText}`;

}

else {

// Write source map file

writeFile(host, diagnostics, sourceMapData.sourceMapFilePath, sourceMapText, /*writeByteOrderMark*/ false);

sourceMapUrl = `//# sourceMappingURL=${sourceMapData.jsSourceMappingURL}`;

}

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

writeJavaScriptFile(emitOutput + sourceMapUrl, writeByteOrderMark);

}

// Initialize source map data

let sourceMapJsFile = getBaseFileName(normalizeSlashes(jsFilePath));

sourceMapData = {

sourceMapFilePath: jsFilePath + ".map",

jsSourceMappingURL: sourceMapJsFile + ".map",

sourceMapFile: sourceMapJsFile,

sourceMapSourceRoot: compilerOptions.sourceRoot || "",

sourceMapSources: [],

inputSourceFileNames: [],

sourceMapNames: [],

sourceMapMappings: "",

sourceMapSourcesContent: undefined,

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

}

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

// The relative paths are relative to the common directory

sourceMapDir = combinePaths(host.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

host.getCurrentDirectory(),

host.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true);

}

else {

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

}

}

else {

sourceMapDir = getDirectoryPath(normalizePath(jsFilePath));

}

function emitNodeWithSourceMap(node: Node) {

if (node) {

if (nodeIsSynthesized(node)) {

return emitNodeWithoutSourceMap(node);

}

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

recordEmitNodeStartSpan(node);

emitNodeWithoutSourceMap(node);

recordEmitNodeEndSpan(node);

}

else {

recordNewSourceFileStart(<SourceFile>node);

emitNodeWithoutSourceMap(node);

}

}

}

writeEmittedFiles = writeJavaScriptAndSourceMapFile;

emit = emitNodeWithSourceMap;

emitStart = recordEmitNodeStartSpan;

emitEnd = recordEmitNodeEndSpan;

emitToken = writeTextWithSpanRecord;

scopeEmitStart = recordScopeNameOfNode;

scopeEmitEnd = recordScopeNameEnd;

writeComment = writeCommentRangeWithMap;

}

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

writeFile(host, diagnostics, jsFilePath, emitOutput, writeByteOrderMark);

}

// Create a temporary variable with a unique unused name.

function createTempVariable(flags: TempFlags): Identifier {

let result = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);

result.text = makeTempVariableName(flags);

return result;

}

function recordTempDeclaration(name: Identifier): void {

if (!tempVariables) {

tempVariables = [];

}

tempVariables.push(name);

}

function createAndRecordTempVariable(flags: TempFlags): Identifier {

let temp = createTempVariable(flags);

recordTempDeclaration(temp);

return temp;

}

function emitTempDeclarations(newLine: boolean) {

if (tempVariables) {

if (newLine) {

writeLine();

}

else {

write(" ");

}

write("var ");

emitCommaList(tempVariables);

write(";");

}

}

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

let 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 emitParenthesizedIf(node: Node, parenthesized: boolean) {

if (parenthesized) {

write("(");

}

emit(node);

if (parenthesized) {

write(")");

}

}

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

if (nodeList.hasTrailingComma) {

write(",");

}

}

function emitLinePreservingList(parent: Node, nodes: NodeArray<Node>, allowTrailingComma: boolean, spacesBetweenBraces: boolean) {

Debug.assert(nodes.length > 0);

increaseIndent();

if (nodeStartPositionsAreOnSameLine(parent, nodes[0])) {

if (spacesBetweenBraces) {

write(" ");

}

}

else {

writeLine();

}

for (let i = 0, n = nodes.length; i < n; i++) {

if (i) {

if (nodeEndIsOnSameLineAsNodeStart(nodes[i - 1], nodes[i])) {

write(", ");

}

else {

write(",");

writeLine();

}

}

emit(nodes[i]);

}

if (nodes.hasTrailingComma && allowTrailingComma) {

write(",");

}

decreaseIndent();

if (nodeEndPositionsAreOnSameLine(parent, lastOrUndefined(nodes))) {

if (spacesBetweenBraces) {

write(" ");

}

}

else {

writeLine();

}

}

function emitList<TNode extends Node>(nodes: TNode[], start: number, count: number, multiLine: boolean, trailingComma: boolean, leadingComma?: boolean, noTrailingNewLine?: boolean, emitNode?: (node: TNode) => void): number {

if (!emitNode) {

emitNode = emit;

}

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

if (multiLine) {

if (i || leadingComma) {

write(",");

}

writeLine();

}

else {

if (i || leadingComma) {

write(", ");

}

}

emitNode(nodes[start + i]);

leadingComma = true;

}

if (trailingComma) {

write(",");

}

if (multiLine && !noTrailingNewLine) {

writeLine();

}

return count;

}

function emitCommaList(nodes: Node[]) {

if (nodes) {

emitList(nodes, 0, nodes.length, /*multiline*/ false, /*trailingComma*/ false);

}

}

function emitLines(nodes: Node[]) {

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

}

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

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

writeLine();

emit(nodes[i]);

}

}

function isBinaryOrOctalIntegerLiteral(node: LiteralExpression, text: string): boolean {

if (node.kind === SyntaxKind.NumericLiteral && text.length > 1) {

switch (text.charCodeAt(1)) {

case CharacterCodes.b:

case CharacterCodes.B:

case CharacterCodes.o:

case CharacterCodes.O:

return true;

}

}

return false;

}

function emitLiteral(node: LiteralExpression) {

let text = getLiteralText(node);

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

writer.writeLiteral(text);

}

// For versions below ES6, emit binary & octal literals in their canonical decimal form.

else if (languageVersion < ScriptTarget.ES6 && isBinaryOrOctalIntegerLiteral(node, text)) {

write(node.text);