// emit output for the __extends helper function

var extendsHelper = "\nvar __extends = this.__extends || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n __.prototype = b.prototype;\n d.prototype = new __();\n};";

// emit output for the __decorate helper function

var decorateHelper = "\nvar __decorate = this.__decorate || (typeof Reflect === \"object\" && Reflect.decorate) || function (decorators, target, key, desc) {\n switch (arguments.length) {\n case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);\n case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);\n case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);\n }\n};";

// emit output for the __metadata helper function

var metadataHelper = "\nvar __metadata = this.__metadata || (typeof Reflect === \"object\" && Reflect.metadata) || function () { };";

// emit output for the __param helper function

var paramHelper = "\nvar __param = this.__param || function(index, decorator) { return function (target, key) { decorator(target, key, index); } };";

var compilerOptions = host.getCompilerOptions();

var languageVersion = compilerOptions.target || 0 /* ES3 */;

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

var diagnostics = [];

var newLine = host.getNewLine();

if (targetSourceFile === undefined) {

ts.forEach(host.getSourceFiles(), function (sourceFile) {

if (ts.shouldEmitToOwnFile(sourceFile, compilerOptions)) {

var jsFilePath = ts.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 (ts.shouldEmitToOwnFile(targetSourceFile, compilerOptions)) {

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

emitFile(jsFilePath, targetSourceFile);

}

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

emitFile(compilerOptions.out);

}

}

// Sort and make the unique list of diagnostics

diagnostics = ts.sortAndDeduplicateDiagnostics(diagnostics);

return {

emitSkipped: false,

diagnostics: diagnostics,

sourceMaps: sourceMapDataList

};

function isNodeDescendentOf(node, ancestor) {

while (node) {

if (node === ancestor)

return true;

node = node.parent;

}

return false;

}

function isUniqueLocalName(name, container) {

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

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

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

if (node.locals[name].flags & (107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */)) {

return false;

}

}

}

return true;

}

function emitJavaScript(jsFilePath, root) {

var writer = ts.createTextWriter(newLine);

var write = writer.write;

var writeTextOfNode = writer.writeTextOfNode;

var writeLine = writer.writeLine;

var increaseIndent = writer.increaseIndent;

var decreaseIndent = writer.decreaseIndent;

var currentSourceFile;

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

var exportFunctionForFile;

var generatedNameSet = {};

var nodeToGeneratedName = [];

var blockScopedVariableToGeneratedName;

var computedPropertyNamesToGeneratedNames;

var extendsEmitted = false;

var decorateEmitted = false;

var paramEmitted = false;

var tempFlags = 0;

var tempVariables;

var tempParameters;

var externalImports;

var exportSpecifiers;

var exportEquals;

var hasExportStars;

/** write emitted output to disk*/

var writeEmittedFiles = writeJavaScriptFile;

var detachedCommentsInfo;

var writeComment = ts.writeCommentRange;

/** Emit a node */

var emit = emitNodeWithoutSourceMap;

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

var emitStart = function (node) { };

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

var emitEnd = function (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, scopeName) { };

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

var scopeEmitEnd = function () { };

/** Sourcemap data that will get encoded */

var sourceMapData;

if (compilerOptions.sourceMap) {

initializeEmitterWithSourceMaps();

}

if (root) {

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

emitSourceFile(root);

}

else {

ts.forEach(host.getSourceFiles(), function (sourceFile) {

if (!isExternalModuleOrDeclarationFile(sourceFile)) {

emitSourceFile(sourceFile);

}

});

}

writeLine();

writeEmittedFiles(writer.getText(), compilerOptions.emitBOM);

return;

function emitSourceFile(sourceFile) {

currentSourceFile = sourceFile;

exportFunctionForFile = undefined;

emit(sourceFile);

}

function isUniqueName(name) {

return !resolver.hasGlobalName(name) &&

!ts.hasProperty(currentSourceFile.identifiers, name) &&

!ts.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) {

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

var name = flags === 268435456 /* _i */ ? "_i" : "_n";

if (isUniqueName(name)) {

tempFlags |= flags;

return name;

}

}

while (true) {

var count = tempFlags & 268435455 /* CountMask */;

tempFlags++;

// Skip over 'i' and 'n'

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

var name_1 = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26);

if (isUniqueName(name_1)) {

return name_1;

}

}

}

}

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

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

if (baseName.charCodeAt(baseName.length - 1) !== 95 /* _ */) {

baseName += "_";

}

var i = 1;

while (true) {

var generatedName = baseName + i;

if (isUniqueName(generatedName)) {

return generatedNameSet[generatedName] = generatedName;

}

i++;

}

}

function assignGeneratedName(node, name) {

nodeToGeneratedName[ts.getNodeId(node)] = ts.unescapeIdentifier(name);

}

function generateNameForFunctionOrClassDeclaration(node) {

if (!node.name) {

assignGeneratedName(node, makeUniqueName("default"));

}

}

function generateNameForModuleOrEnum(node) {

if (node.name.kind === 65 /* Identifier */) {

var name_2 = node.name.text;

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

assignGeneratedName(node, isUniqueLocalName(name_2, node) ? name_2 : makeUniqueName(name_2));

}

}

function generateNameForImportOrExportDeclaration(node) {

var expr = ts.getExternalModuleName(node);

var baseName = expr.kind === 8 /* StringLiteral */ ?

ts.escapeIdentifier(ts.makeIdentifierFromModuleName(expr.text)) : "module";

assignGeneratedName(node, makeUniqueName(baseName));

}

function generateNameForImportDeclaration(node) {

if (node.importClause) {

generateNameForImportOrExportDeclaration(node);

}

}

function generateNameForExportDeclaration(node) {

if (node.moduleSpecifier) {

generateNameForImportOrExportDeclaration(node);

}

}

function generateNameForExportAssignment(node) {

if (node.expression && node.expression.kind !== 65 /* Identifier */) {

assignGeneratedName(node, makeUniqueName("default"));

}

}

function generateNameForNode(node) {

switch (node.kind) {

case 200 /* FunctionDeclaration */:

case 201 /* ClassDeclaration */:

case 174 /* ClassExpression */:

generateNameForFunctionOrClassDeclaration(node);

break;

case 205 /* ModuleDeclaration */:

generateNameForModuleOrEnum(node);

generateNameForNode(node.body);

break;

case 204 /* EnumDeclaration */:

generateNameForModuleOrEnum(node);

break;

case 209 /* ImportDeclaration */:

generateNameForImportDeclaration(node);

break;

case 215 /* ExportDeclaration */:

generateNameForExportDeclaration(node);

break;

case 214 /* ExportAssignment */:

generateNameForExportAssignment(node);

break;

}

}

function getGeneratedNameForNode(node) {

var nodeId = ts.getNodeId(node);

if (!nodeToGeneratedName[nodeId]) {

generateNameForNode(node);

}

return nodeToGeneratedName[nodeId];

}

function initializeEmitterWithSourceMaps() {

var sourceMapDir; // 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 = {};

var sourceMapNameIndices = [];

function getSourceMapNameIndex() {

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

}

// Last recorded and encoded spans

var lastRecordedSourceMapSpan;

var lastEncodedSourceMapSpan = {

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

function base64FormatEncode(inValue) {

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

var sourceLinePos = ts.getLineAndCharacterOfPosition(currentSourceFile, pos);

// Convert the location to be one-based.

sourceLinePos.line++;

sourceLinePos.character++;

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

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

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

}

function recordEmitNodeEndSpan(node) {

recordSourceMapSpan(node.end);

}

function writeTextWithSpanRecord(tokenKind, startPos, emitFn) {

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

recordSourceMapSpan(tokenStartPos);

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

recordSourceMapSpan(tokenEndPos);

return tokenEndPos;

}

function recordNewSourceFileStart(node) {

// 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 ? host.getCommonSourceDirectory() : sourceMapDir;

sourceMapData.sourceMapSources.push(ts.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);

}

function recordScopeNameOfNode(node, scopeName) {

function recordScopeNameIndex(scopeNameIndex) {

sourceMapNameIndices.push(scopeNameIndex);

}

function recordScopeNameStart(scopeName) {

var scopeNameIndex = -1;

if (scopeName) {

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

var name_3 = node.name;

if (!name_3 || name_3.kind !== 127 /* ComputedPropertyName */) {

scopeName = "." + scopeName;

}

scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName;

}

scopeNameIndex = ts.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 === 200 /* FunctionDeclaration */ ||

node.kind === 162 /* FunctionExpression */ ||

node.kind === 134 /* MethodDeclaration */ ||

node.kind === 133 /* MethodSignature */ ||

node.kind === 136 /* GetAccessor */ ||

node.kind === 137 /* SetAccessor */ ||

node.kind === 205 /* ModuleDeclaration */ ||

node.kind === 201 /* ClassDeclaration */ ||

node.kind === 204 /* EnumDeclaration */) {

// Declaration and has associated name use it

if (node.name) {

var name_4 = node.name;

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

scopeName = name_4.kind === 127 /* ComputedPropertyName */

? ts.getTextOfNode(name_4)

: node.name.text;

}

recordScopeNameStart(scopeName);

}

else {

// Block just use the name from upper level scope

recordScopeNameIndex(getSourceMapNameIndex());

}

}

function recordScopeNameEnd() {

sourceMapNameIndices.pop();

}

;

function writeCommentRangeWithMap(curentSourceFile, writer, comment, newLine) {

recordSourceMapSpan(comment.pos);

ts.writeCommentRange(currentSourceFile, writer, comment, newLine);

recordSourceMapSpan(comment.end);

}

function serializeSourceMapContents(version, file, sourceRoot, sources, names, mappings) {

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

return JSON.stringify({

version: version,

file: file,

sourceRoot: sourceRoot,

sources: sources,

names: names,

mappings: mappings

});

}

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

function serializeStringArray(list) {

var output = "";

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

if (i) {

output += ",";

}

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

}

return output;

}

}

function writeJavaScriptAndSourceMapFile(emitOutput, writeByteOrderMark) {

// Write source map file

encodeLastRecordedSourceMapSpan();

ts.writeFile(host, diagnostics, sourceMapData.sourceMapFilePath, serializeSourceMapContents(3, sourceMapData.sourceMapFile, sourceMapData.sourceMapSourceRoot, sourceMapData.sourceMapSources, sourceMapData.sourceMapNames, sourceMapData.sourceMapMappings), 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 = ts.getBaseFileName(ts.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) !== 47 /* slash */) {

sourceMapData.sourceMapSourceRoot += ts.directorySeparator;

}

if (compilerOptions.mapRoot) {

sourceMapDir = ts.normalizeSlashes(compilerOptions.mapRoot);

if (root) {

// 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 = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(root, host, sourceMapDir));

}

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

// The relative paths are relative to the common directory

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

sourceMapData.jsSourceMappingURL = ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(jsFilePath)), ts.combinePaths(sourceMapDir, sourceMapData.jsSourceMappingURL), host.getCurrentDirectory(), host.getCanonicalFileName,

/*isAbsolutePathAnUrl*/ true);

}

else {

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

}

}

else {

sourceMapDir = ts.getDirectoryPath(ts.normalizePath(jsFilePath));

}

function emitNodeWithSourceMap(node, allowGeneratedIdentifiers) {

if (node) {

if (ts.nodeIsSynthesized(node)) {

return emitNodeWithoutSourceMap(node, false);

}

if (node.kind != 227 /* SourceFile */) {

recordEmitNodeStartSpan(node);

emitNodeWithoutSourceMap(node, allowGeneratedIdentifiers);

recordEmitNodeEndSpan(node);

}

else {

recordNewSourceFileStart(node);

emitNodeWithoutSourceMap(node, false);

}

}

}

writeEmittedFiles = writeJavaScriptAndSourceMapFile;

emit = emitNodeWithSourceMap;

emitStart = recordEmitNodeStartSpan;

emitEnd = recordEmitNodeEndSpan;

emitToken = writeTextWithSpanRecord;

scopeEmitStart = recordScopeNameOfNode;

scopeEmitEnd = recordScopeNameEnd;

writeComment = writeCommentRangeWithMap;

}

function writeJavaScriptFile(emitOutput, writeByteOrderMark) {

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

}

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

function createTempVariable(flags) {

var result = ts.createSynthesizedNode(65 /* Identifier */);

result.text = makeTempVariableName(flags);

return result;

}

function recordTempDeclaration(name) {

if (!tempVariables) {

tempVariables = [];

}

tempVariables.push(name);

}

function createAndRecordTempVariable(flags) {

var temp = createTempVariable(flags);

recordTempDeclaration(temp);

return temp;

}

function emitTempDeclarations(newLine) {

if (tempVariables) {

if (newLine) {

writeLine();

}

else {

write(" ");

}

write("var ");

emitCommaList(tempVariables);

write(";");

}

}

function emitTokenText(tokenKind, startPos, emitFn) {

var tokenString = ts.tokenToString(tokenKind);

if (emitFn) {

emitFn();

}

else {

write(tokenString);

}

return startPos + tokenString.length;

}

function emitOptional(prefix, node) {

if (node) {

write(prefix);

emit(node);

}

}

function emitParenthesizedIf(node, parenthesized) {

if (parenthesized) {

write("(");

}

emit(node);

if (parenthesized) {

write(")");

}

}

function emitTrailingCommaIfPresent(nodeList) {

if (nodeList.hasTrailingComma) {

write(",");

}

}

function emitLinePreservingList(parent, nodes, allowTrailingComma, spacesBetweenBraces) {

ts.Debug.assert(nodes.length > 0);

increaseIndent();

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

if (spacesBetweenBraces) {

write(" ");

}

}

else {

writeLine();

}

for (var 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, ts.lastOrUndefined(nodes))) {

if (spacesBetweenBraces) {

write(" ");

}

}

else {

writeLine();

}

}

function emitList(nodes, start, count, multiLine, trailingComma, leadingComma, noTrailingNewLine, emitNode) {

if (!emitNode) {

emitNode = emit;

}

for (var 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) {

if (nodes) {

emitList(nodes, 0, nodes.length, false, false);

}

}

function emitLines(nodes) {

emitLinesStartingAt(nodes, 0);

}

function emitLinesStartingAt(nodes, startIndex) {

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

writeLine();

emit(nodes[i]);

}

}

function isBinaryOrOctalIntegerLiteral(node, text) {

if (node.kind === 7 /* NumericLiteral */ && text.length > 1) {

switch (text.charCodeAt(1)) {

case 98 /* b */:

case 66 /* B */:

case 111 /* o */:

case 79 /* O */:

return true;

}

}

return false;

}

function emitLiteral(node) {

var text = getLiteralText(node);

if (compilerOptions.sourceMap && (node.kind === 8 /* StringLiteral */ || ts.isTemplateLiteralKind(node.kind))) {

writer.writeLiteral(text);

}

else if (languageVersion < 2 /* ES6 */ && isBinaryOrOctalIntegerLiteral(node, text)) {

write(node.text);

}

else {

write(text);

}

}

function getLiteralText(node) {

// Any template literal or string literal with an extended escape

// (e.g. "\u{0067}") will need to be downleveled as a escaped string literal.

if (languageVersion < 2 /* ES6 */ && (ts.isTemplateLiteralKind(node.kind) || node.hasExtendedUnicodeEscape)) {

return getQuotedEscapedLiteralText('"', node.text, '"');

}

// If we don't need to downlevel and we can reach the original source text using

// the node's parent reference, then simply get the text as it was originally written.

if (node.parent) {

return ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node);

}

// If we can't reach the original source text, use the canonical form if it's a number,

// or an escaped quoted form of the original text if it's string-like.

switch (node.kind) {

case 8 /* StringLiteral */:

return getQuotedEscapedLiteralText('"', node.text, '"');

case 10 /* NoSubstitutionTemplateLiteral */:

return getQuotedEscapedLiteralText('`', node.text, '`');

case 11 /* TemplateHead */:

return getQuotedEscapedLiteralText('`', node.text, '${');

case 12 /* TemplateMiddle */:

return getQuotedEscapedLiteralText('}', node.text, '${');

case 13 /* TemplateTail */:

return getQuotedEscapedLiteralText('}', node.text, '`');

case 7 /* NumericLiteral */:

return node.text;

}

ts.Debug.fail("Literal kind '" + node.kind + "' not accounted for.");

}

function getQuotedEscapedLiteralText(leftQuote, text, rightQuote) {

return leftQuote + ts.escapeNonAsciiCharacters(ts.escapeString(text)) + rightQuote;

}

function emitDownlevelRawTemplateLiteral(node) {

// Find original source text, since we need to emit the raw strings of the tagged template.

// The raw strings contain the (escaped) strings of what the user wrote.

// Examples: `\n` is converted to "\\n", a template string with a newline to "\n".

var text = ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node);

// text contains the original source, it will also contain quotes ("`"), dolar signs and braces ("${" and "}"),

// thus we need to remove those characters.

// First template piece starts with "`", others with "}"

// Last template piece ends with "`", others with "${"

var isLast = node.kind === 10 /* NoSubstitutionTemplateLiteral */ || node.kind === 13 /* TemplateTail */;

text = text.substring(1, text.length - (isLast ? 1 : 2));

// Newline normalization:

// ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's

// <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for both TV and TRV.

text = text.replace(/\r\n?/g, "\n");

text = ts.escapeString(text);

write('"' + text + '"');

}

function emitDownlevelTaggedTemplateArray(node, literalEmitter) {

write("[");

if (node.template.kind === 10 /* NoSubstitutionTemplateLiteral */) {

literalEmitter(node.template);

}

else {

literalEmitter(node.template.head);

ts.forEach(node.template.templateSpans, function (child) {

write(", ");

literalEmitter(child.literal);

});

}

write("]");