Auto = 0x00000000, // No preferred name

CountMask = 0x0FFFFFFF, // Temp variable counter

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

const delimiters = createDelimiterMap();

const brackets = createBracketsMap();

// emit output for the __extends helper function

const extendsHelper = `

// Emit output for the __assign helper function.

// This is typically used for JSX spread attributes,

// and can be used for object literal spread properties.

const assignHelper = `

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

// emit output for the __awaiter helper function

const awaiterHelper = `

// The __generator helper is used by down-level transformations to emulate the runtime

// semantics of an ES2015 generator function. When called, this helper returns an

// object that implements the Iterator protocol, in that it has `next`, `return`, and

// `throw` methods that step through the generator when invoked.

//

// parameters:

// thisArg The value to use as the `this` binding for the transformed generator body.

// body A function that acts as the transformed generator body.

//

// variables:

// _ Persistent state for the generator that is shared between the helper and the

// generator body. The state object has the following members:

// sent() - A method that returns or throws the current completion value.

// label - The next point at which to resume evaluation of the generator body.

// trys - A stack of protected regions (try/catch/finally blocks).

// ops - A stack of pending instructions when inside of a finally block.

// f A value indicating whether the generator is executing.

// y An iterator to delegate for a yield*.

// t A temporary variable that holds one of the following values (note that these

// cases do not overlap):

// - The completion value when resuming from a `yield` or `yield*`.

// - The error value for a catch block.

// - The current protected region (array of try/catch/finally/end labels).

// - The verb (`next`, `throw`, or `return` method) to delegate to the expression

// of a `yield*`.

// - The result of evaluating the verb delegated to the expression of a `yield*`.

//

// functions:

// verb(n) Creates a bound callback to the `step` function for opcode `n`.

// step(op) Evaluates opcodes in a generator body until execution is suspended or

// completed.

//

// The __generator helper understands a limited set of instructions:

// 0: next(value?) - Start or resume the generator with the specified value.

// 1: throw(error) - Resume the generator with an exception. If the generator is

// suspended inside of one or more protected regions, evaluates

// any intervening finally blocks between the current label and

// the nearest catch block or function boundary. If uncaught, the

// exception is thrown to the caller.

// 2: return(value?) - Resume the generator as if with a return. If the generator is

// suspended inside of one or more protected regions, evaluates any

// intervening finally blocks.

// 3: break(label) - Jump to the specified label. If the label is outside of the

// current protected region, evaluates any intervening finally

// blocks.

// 4: yield(value?) - Yield execution to the caller with an optional value. When

// resumed, the generator will continue at the next label.

// 5: yield*(value) - Delegates evaluation to the supplied iterator. When

// delegation completes, the generator will continue at the next

// label.

// 6: catch(error) - Handles an exception thrown from within the generator body. If

// the current label is inside of one or more protected regions,

// evaluates any intervening finally blocks between the current

// label and the nearest catch block or function boundary. If

// uncaught, the exception is thrown to the caller.

// 7: endfinally - Ends a finally block, resuming the last instruction prior to

// entering a finally block.

//

// For examples of how these are used, see the comments in ./transformers/generators.ts

const generatorHelper = `

// emit output for the __export helper function

const exportStarHelper = `

// emit output for the UMD helper function.

const umdHelper = `

const superHelper = `

const advancedSuperHelper = `

const compilerOptions = host.getCompilerOptions();

const languageVersion = getEmitScriptTarget(compilerOptions);

const moduleKind = getEmitModuleKind(compilerOptions);

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

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

const emitterDiagnostics = createDiagnosticCollection();

const newLine = host.getNewLine();

const transformers = getTransformers(compilerOptions);

const writer = createTextWriter(newLine);

const {

write,

writeLine,

increaseIndent,

decreaseIndent

} = writer;

const sourceMap = createSourceMapWriter(host, writer);

const {

emitStart,

emitEnd,

emitTokenStart,

emitTokenEnd

} = sourceMap;

const comments = createCommentWriter(host, writer, sourceMap);

const {

emitNodeWithComments,

emitBodyWithDetachedComments,

emitTrailingCommentsOfPosition

} = comments;

let nodeIdToGeneratedName: string[];

let autoGeneratedIdToGeneratedName: string[];

let generatedNameSet: Map<string>;

let tempFlags: TempFlags;

let currentSourceFile: SourceFile;

let currentText: string;

let currentFileIdentifiers: Map<string>;

let extendsEmitted: boolean;

let assignEmitted: boolean;

let decorateEmitted: boolean;

let paramEmitted: boolean;

let awaiterEmitted: boolean;

let isOwnFileEmit: boolean;

let emitSkipped = false;

performance.mark("beforeTransform");

// Transform the source files

const transformed = transformFiles(

resolver,

host,

getSourceFilesToEmit(host, targetSourceFile),

transformers);

performance.measure("transformTime", "beforeTransform");

// Extract helpers from the result

const {

getTokenSourceMapRange,

isSubstitutionEnabled,

isEmitNotificationEnabled,

onSubstituteNode,

onEmitNode

} = transformed;

performance.mark("beforePrint");

// Emit each output file

forEachTransformedEmitFile(host, transformed.getSourceFiles(), emitFile);

// Clean up after transformation

transformed.dispose();

performance.measure("printTime", "beforePrint");

return {

emitSkipped,

diagnostics: emitterDiagnostics.getDiagnostics(),

emittedFiles: emittedFilesList,

sourceMaps: sourceMapDataList

};

function emitFile(jsFilePath: string, sourceMapFilePath: string, declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {

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

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

printFile(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);

}

else {

emitSkipped = true;

}

if (declarationFilePath) {

emitSkipped = writeDeclarationFile(declarationFilePath, getOriginalSourceFiles(sourceFiles), isBundledEmit, host, resolver, emitterDiagnostics) || emitSkipped;

}

if (!emitSkipped && emittedFilesList) {

emittedFilesList.push(jsFilePath);

if (sourceMapFilePath) {

emittedFilesList.push(sourceMapFilePath);

}

if (declarationFilePath) {

emittedFilesList.push(declarationFilePath);

}

}

}

function printFile(jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {

sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);

nodeIdToGeneratedName = [];

autoGeneratedIdToGeneratedName = [];

generatedNameSet = createMap<string>();

isOwnFileEmit = !isBundledEmit;

// Emit helpers from all the files

if (isBundledEmit && moduleKind) {

for (const sourceFile of sourceFiles) {

emitEmitHelpers(sourceFile);

}

}

// Print each transformed source file.

forEach(sourceFiles, printSourceFile);

writeLine();

const sourceMappingURL = sourceMap.getSourceMappingURL();

if (sourceMappingURL) {

write(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Sometimes tools can sometimes see this line as a source mapping url comment

}

// Write the source map

if (compilerOptions.sourceMap && !compilerOptions.inlineSourceMap) {

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

}

// Record source map data for the test harness.

if (sourceMapDataList) {

sourceMapDataList.push(sourceMap.getSourceMapData());

}

// Write the output file

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

// Reset state

sourceMap.reset();

comments.reset();

writer.reset();

tempFlags = TempFlags.Auto;

currentSourceFile = undefined;

currentText = undefined;

extendsEmitted = false;

assignEmitted = false;

decorateEmitted = false;

paramEmitted = false;

awaiterEmitted = false;

isOwnFileEmit = false;

}

function printSourceFile(node: SourceFile) {

currentSourceFile = node;

currentText = node.text;

currentFileIdentifiers = node.identifiers;

sourceMap.setSourceFile(node);

comments.setSourceFile(node);

emitNodeWithNotification(node, emitWorker);

}

/**

function emit(node: Node) {

emitNodeWithNotification(node, emitWithComments);

}

/**

function emitWithComments(node: Node) {

emitNodeWithComments(node, emitWithSourceMap);

}

/**

function emitWithSourceMap(node: Node) {

emitNodeWithSourceMap(node, emitWorker);

}

function emitIdentifierName(node: Identifier) {

if (node) {

emitNodeWithNotification(node, emitIdentifierNameWithComments);

}

}

function emitIdentifierNameWithComments(node: Identifier) {

emitNodeWithComments(node, emitWorker);

}

/**

function emitExpression(node: Expression) {

emitNodeWithNotification(node, emitExpressionWithComments);

}

/**

function emitExpressionWithComments(node: Expression) {

emitNodeWithComments(node, emitExpressionWithSourceMap);

}

/**

function emitExpressionWithSourceMap(node: Expression) {

emitNodeWithSourceMap(node, emitExpressionWorker);

}

/**

function emitNodeWithNotification(node: Node, emitCallback: (node: Node) => void) {

if (node) {

if (isEmitNotificationEnabled(node)) {

onEmitNode(node, emitCallback);

}

else {

emitCallback(node);

}

}

}

function emitNodeWithSourceMap(node: Node, emitCallback: (node: Node) => void) {

if (node) {

emitStart(/*range*/ node, /*contextNode*/ node, shouldSkipLeadingSourceMapForNode, shouldSkipSourceMapForChildren, getSourceMapRange);

emitCallback(node);

emitEnd(/*range*/ node, /*contextNode*/ node, shouldSkipTrailingSourceMapForNode, shouldSkipSourceMapForChildren, getSourceMapRange);

}

}

function getSourceMapRange(node: Node) {

return node.sourceMapRange || node;

}

/**

function shouldSkipLeadingCommentsForNode(node: Node) {

return isNotEmittedStatement(node)

|| (node.emitFlags & NodeEmitFlags.NoLeadingComments) !== 0;

}

/**

function shouldSkipLeadingSourceMapForNode(node: Node) {

return isNotEmittedStatement(node)

|| (node.emitFlags & NodeEmitFlags.NoLeadingSourceMap) !== 0;

}

/**

function shouldSkipTrailingSourceMapForNode(node: Node) {

return isNotEmittedStatement(node)

|| (node.emitFlags & NodeEmitFlags.NoTrailingSourceMap) !== 0;

}

/**

function shouldSkipSourceMapForChildren(node: Node) {

return (node.emitFlags & NodeEmitFlags.NoNestedSourceMaps) !== 0;

}

function emitWorker(node: Node): void {

if (tryEmitSubstitute(node, emitWorker, /*isExpression*/ false)) {

return;

}

const kind = node.kind;

switch (kind) {

// Pseudo-literals

case SyntaxKind.TemplateHead:

case SyntaxKind.TemplateMiddle:

case SyntaxKind.TemplateTail:

return emitLiteral(<LiteralExpression>node);

// Identifiers

case SyntaxKind.Identifier:

return emitIdentifier(<Identifier>node);

// Reserved words

case SyntaxKind.ConstKeyword:

case SyntaxKind.DefaultKeyword:

case SyntaxKind.ExportKeyword:

case SyntaxKind.VoidKeyword:

// Strict mode reserved words

case SyntaxKind.PrivateKeyword:

case SyntaxKind.ProtectedKeyword:

case SyntaxKind.PublicKeyword:

case SyntaxKind.StaticKeyword:

// Contextual keywords

case SyntaxKind.AbstractKeyword:

case SyntaxKind.AnyKeyword:

case SyntaxKind.AsyncKeyword:

case SyntaxKind.BooleanKeyword:

case SyntaxKind.DeclareKeyword:

case SyntaxKind.NumberKeyword:

case SyntaxKind.ReadonlyKeyword:

case SyntaxKind.StringKeyword:

case SyntaxKind.SymbolKeyword:

case SyntaxKind.GlobalKeyword:

return writeTokenNode(node);

// Parse tree nodes

// Names

case SyntaxKind.QualifiedName:

return emitQualifiedName(<QualifiedName>node);

case SyntaxKind.ComputedPropertyName:

return emitComputedPropertyName(<ComputedPropertyName>node);

// Signature elements

case SyntaxKind.TypeParameter:

return emitTypeParameter(<TypeParameterDeclaration>node);

case SyntaxKind.Parameter:

return emitParameter(<ParameterDeclaration>node);

case SyntaxKind.Decorator:

return emitDecorator(<Decorator>node);

// Type members

case SyntaxKind.PropertySignature:

return emitPropertySignature(<PropertySignature>node);

case SyntaxKind.PropertyDeclaration:

return emitPropertyDeclaration(<PropertyDeclaration>node);

case SyntaxKind.MethodSignature:

return emitMethodSignature(<MethodSignature>node);

case SyntaxKind.MethodDeclaration:

return emitMethodDeclaration(<MethodDeclaration>node);

case SyntaxKind.Constructor:

return emitConstructor(<ConstructorDeclaration>node);

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

return emitAccessorDeclaration(<AccessorDeclaration>node);

case SyntaxKind.CallSignature:

return emitCallSignature(<CallSignatureDeclaration>node);

case SyntaxKind.ConstructSignature:

return emitConstructSignature(<ConstructSignatureDeclaration>node);

case SyntaxKind.IndexSignature:

return emitIndexSignature(<IndexSignatureDeclaration>node);

// Types

case SyntaxKind.TypePredicate:

return emitTypePredicate(<TypePredicateNode>node);

case SyntaxKind.TypeReference:

return emitTypeReference(<TypeReferenceNode>node);

case SyntaxKind.FunctionType:

return emitFunctionType(<FunctionTypeNode>node);

case SyntaxKind.ConstructorType:

return emitConstructorType(<ConstructorTypeNode>node);

case SyntaxKind.TypeQuery:

return emitTypeQuery(<TypeQueryNode>node);

case SyntaxKind.TypeLiteral:

return emitTypeLiteral(<TypeLiteralNode>node);

case SyntaxKind.ArrayType:

return emitArrayType(<ArrayTypeNode>node);

case SyntaxKind.TupleType:

return emitTupleType(<TupleTypeNode>node);

case SyntaxKind.UnionType:

return emitUnionType(<UnionTypeNode>node);

case SyntaxKind.IntersectionType:

return emitIntersectionType(<IntersectionTypeNode>node);

case SyntaxKind.ParenthesizedType:

return emitParenthesizedType(<ParenthesizedTypeNode>node);

case SyntaxKind.ExpressionWithTypeArguments:

return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>node);

case SyntaxKind.ThisType:

return emitThisType(<ThisTypeNode>node);

case SyntaxKind.LiteralType:

return emitLiteralType(<LiteralTypeNode>node);

// Binding patterns

case SyntaxKind.ObjectBindingPattern:

return emitObjectBindingPattern(<ObjectBindingPattern>node);

case SyntaxKind.ArrayBindingPattern:

return emitArrayBindingPattern(<ArrayBindingPattern>node);

case SyntaxKind.BindingElement:

return emitBindingElement(<BindingElement>node);

// Misc

case SyntaxKind.TemplateSpan:

return emitTemplateSpan(<TemplateSpan>node);

case SyntaxKind.SemicolonClassElement:

return emitSemicolonClassElement(<SemicolonClassElement>node);

// Statements

case SyntaxKind.Block:

return emitBlock(<Block>node);

case SyntaxKind.VariableStatement:

return emitVariableStatement(<VariableStatement>node);

case SyntaxKind.EmptyStatement:

return emitEmptyStatement(<EmptyStatement>node);

case SyntaxKind.ExpressionStatement:

return emitExpressionStatement(<ExpressionStatement>node);

case SyntaxKind.IfStatement:

return emitIfStatement(<IfStatement>node);

case SyntaxKind.DoStatement:

return emitDoStatement(<DoStatement>node);

case SyntaxKind.WhileStatement:

return emitWhileStatement(<WhileStatement>node);

case SyntaxKind.ForStatement:

return emitForStatement(<ForStatement>node);

case SyntaxKind.ForInStatement:

return emitForInStatement(<ForInStatement>node);

case SyntaxKind.ForOfStatement:

return emitForOfStatement(<ForOfStatement>node);

case SyntaxKind.ContinueStatement:

return emitContinueStatement(<ContinueStatement>node);

case SyntaxKind.BreakStatement:

return emitBreakStatement(<BreakStatement>node);

case SyntaxKind.ReturnStatement:

return emitReturnStatement(<ReturnStatement>node);

case SyntaxKind.WithStatement:

return emitWithStatement(<WithStatement>node);

case SyntaxKind.SwitchStatement:

return emitSwitchStatement(<SwitchStatement>node);

case SyntaxKind.LabeledStatement:

return emitLabeledStatement(<LabeledStatement>node);

case SyntaxKind.ThrowStatement:

return emitThrowStatement(<ThrowStatement>node);

case SyntaxKind.TryStatement:

return emitTryStatement(<TryStatement>node);

case SyntaxKind.DebuggerStatement:

return emitDebuggerStatement(<DebuggerStatement>node);

// Declarations

case SyntaxKind.VariableDeclaration:

return emitVariableDeclaration(<VariableDeclaration>node);

case SyntaxKind.VariableDeclarationList:

return emitVariableDeclarationList(<VariableDeclarationList>node);

case SyntaxKind.FunctionDeclaration:

return emitFunctionDeclaration(<FunctionDeclaration>node);

case SyntaxKind.ClassDeclaration:

return emitClassDeclaration(<ClassDeclaration>node);

case SyntaxKind.InterfaceDeclaration:

return emitInterfaceDeclaration(<InterfaceDeclaration>node);

case SyntaxKind.TypeAliasDeclaration:

return emitTypeAliasDeclaration(<TypeAliasDeclaration>node);

case SyntaxKind.EnumDeclaration:

return emitEnumDeclaration(<EnumDeclaration>node);

case SyntaxKind.ModuleDeclaration:

return emitModuleDeclaration(<ModuleDeclaration>node);

case SyntaxKind.ModuleBlock:

return emitModuleBlock(<Block>node);

case SyntaxKind.CaseBlock:

return emitCaseBlock(<CaseBlock>node);

case SyntaxKind.ImportEqualsDeclaration:

return emitImportEqualsDeclaration(<ImportEqualsDeclaration>node);

case SyntaxKind.ImportDeclaration:

return emitImportDeclaration(<ImportDeclaration>node);

case SyntaxKind.ImportClause:

return emitImportClause(<ImportClause>node);

case SyntaxKind.NamespaceImport:

return emitNamespaceImport(<NamespaceImport>node);

case SyntaxKind.NamedImports:

return emitNamedImports(<NamedImports>node);

case SyntaxKind.ImportSpecifier:

return emitImportSpecifier(<ImportSpecifier>node);

case SyntaxKind.ExportAssignment:

return emitExportAssignment(<ExportAssignment>node);

case SyntaxKind.ExportDeclaration:

return emitExportDeclaration(<ExportDeclaration>node);

case SyntaxKind.NamedExports:

return emitNamedExports(<NamedExports>node);

case SyntaxKind.ExportSpecifier:

return emitExportSpecifier(<ExportSpecifier>node);

case SyntaxKind.MissingDeclaration:

return;

// Module references

case SyntaxKind.ExternalModuleReference:

return emitExternalModuleReference(<ExternalModuleReference>node);

// JSX (non-expression)

case SyntaxKind.JsxText:

return emitJsxText(<JsxText>node);

case SyntaxKind.JsxOpeningElement:

return emitJsxOpeningElement(<JsxOpeningElement>node);

case SyntaxKind.JsxClosingElement:

return emitJsxClosingElement(<JsxClosingElement>node);

case SyntaxKind.JsxAttribute:

return emitJsxAttribute(<JsxAttribute>node);

case SyntaxKind.JsxSpreadAttribute:

return emitJsxSpreadAttribute(<JsxSpreadAttribute>node);

case SyntaxKind.JsxExpression:

return emitJsxExpression(<JsxExpression>node);

// Clauses

case SyntaxKind.CaseClause:

return emitCaseClause(<CaseClause>node);

case SyntaxKind.DefaultClause:

return emitDefaultClause(<DefaultClause>node);

case SyntaxKind.HeritageClause:

return emitHeritageClause(<HeritageClause>node);

case SyntaxKind.CatchClause:

return emitCatchClause(<CatchClause>node);

// Property assignments

case SyntaxKind.PropertyAssignment:

return emitPropertyAssignment(<PropertyAssignment>node);

case SyntaxKind.ShorthandPropertyAssignment:

return emitShorthandPropertyAssignment(<ShorthandPropertyAssignment>node);

// Enum

case SyntaxKind.EnumMember:

return emitEnumMember(<EnumMember>node);

// Top-level nodes

case SyntaxKind.SourceFile:

return emitSourceFile(<SourceFile>node);

// JSDoc nodes (ignored)

// Transformation nodes (ignored)

}

if (isExpression(node)) {

return emitExpressionWorker(node);

}

}

function emitExpressionWorker(node: Node) {

if (tryEmitSubstitute(node, emitExpressionWorker, /*isExpression*/ true)) {

return;

}

const kind = node.kind;

switch (kind) {

// Literals

case SyntaxKind.NumericLiteral:

return emitNumericLiteral(<NumericLiteral>node);

case SyntaxKind.StringLiteral:

case SyntaxKind.RegularExpressionLiteral:

case SyntaxKind.NoSubstitutionTemplateLiteral:

return emitLiteral(<LiteralExpression>node);

// Identifiers

case SyntaxKind.Identifier:

return emitIdentifier(<Identifier>node);

// Reserved words

case SyntaxKind.FalseKeyword:

case SyntaxKind.NullKeyword:

case SyntaxKind.SuperKeyword:

case SyntaxKind.TrueKeyword:

case SyntaxKind.ThisKeyword:

return writeTokenNode(node);

// Expressions

case SyntaxKind.ArrayLiteralExpression:

return emitArrayLiteralExpression(<ArrayLiteralExpression>node);

case SyntaxKind.ObjectLiteralExpression:

return emitObjectLiteralExpression(<ObjectLiteralExpression>node);

case SyntaxKind.PropertyAccessExpression:

return emitPropertyAccessExpression(<PropertyAccessExpression>node);

case SyntaxKind.ElementAccessExpression:

return emitElementAccessExpression(<ElementAccessExpression>node);

case SyntaxKind.CallExpression:

return emitCallExpression(<CallExpression>node);

case SyntaxKind.NewExpression:

return emitNewExpression(<NewExpression>node);

case SyntaxKind.TaggedTemplateExpression:

return emitTaggedTemplateExpression(<TaggedTemplateExpression>node);

case SyntaxKind.TypeAssertionExpression:

return emitTypeAssertionExpression(<TypeAssertion>node);

case SyntaxKind.ParenthesizedExpression:

return emitParenthesizedExpression(<ParenthesizedExpression>node);

case SyntaxKind.FunctionExpression:

return emitFunctionExpression(<FunctionExpression>node);

case SyntaxKind.ArrowFunction:

return emitArrowFunction(<ArrowFunction>node);

case SyntaxKind.DeleteExpression:

return emitDeleteExpression(<DeleteExpression>node);

case SyntaxKind.TypeOfExpression:

return emitTypeOfExpression(<TypeOfExpression>node);

case SyntaxKind.VoidExpression:

return emitVoidExpression(<VoidExpression>node);

case SyntaxKind.AwaitExpression:

return emitAwaitExpression(<AwaitExpression>node);

case SyntaxKind.PrefixUnaryExpression:

return emitPrefixUnaryExpression(<PrefixUnaryExpression>node);

case SyntaxKind.PostfixUnaryExpression:

return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);

case SyntaxKind.BinaryExpression:

return emitBinaryExpression(<BinaryExpression>node);

case SyntaxKind.ConditionalExpression:

return emitConditionalExpression(<ConditionalExpression>node);

case SyntaxKind.TemplateExpression:

return emitTemplateExpression(<TemplateExpression>node);

case SyntaxKind.YieldExpression:

return emitYieldExpression(<YieldExpression>node);

case SyntaxKind.SpreadElementExpression:

return emitSpreadElementExpression(<SpreadElementExpression>node);

case SyntaxKind.ClassExpression:

return emitClassExpression(<ClassExpression>node);

case SyntaxKind.OmittedExpression:

return;

case SyntaxKind.AsExpression:

return emitAsExpression(<AsExpression>node);

case SyntaxKind.NonNullExpression:

return emitNonNullExpression(<NonNullExpression>node);

// JSX

case SyntaxKind.JsxElement:

return emitJsxElement(<JsxElement>node);

case SyntaxKind.JsxSelfClosingElement:

return emitJsxSelfClosingElement(<JsxSelfClosingElement>node);

// Transformation nodes

case SyntaxKind.PartiallyEmittedExpression:

return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);

}

}

//

// Literals/Pseudo-literals

//

// SyntaxKind.NumericLiteral

function emitNumericLiteral(node: NumericLiteral) {

emitLiteral(node);

if (node.trailingComment) {

write(` /*${node.trailingComment}*/`);

}

}

// SyntaxKind.StringLiteral

// SyntaxKind.RegularExpressionLiteral

// SyntaxKind.NoSubstitutionTemplateLiteral

// SyntaxKind.TemplateHead

// SyntaxKind.TemplateMiddle

// SyntaxKind.TemplateTail

function emitLiteral(node: LiteralLikeNode) {

const text = getLiteralTextOfNode(node);

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

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

writer.writeLiteral(text);

}

else {

write(text);

}

}

//

// Identifiers

//

function emitIdentifier(node: Identifier) {

if (node.emitFlags & NodeEmitFlags.UMDDefine) {

writeLines(umdHelper);

}

else {

write(getTextOfNode(node, /*includeTrivia*/ false));

}

}

//

// Names

//

function emitQualifiedName(node: QualifiedName) {

emitEntityName(node.left);

write(".");

emit(node.right);

}

function emitEntityName(node: EntityName) {

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

emitExpression(<Identifier>node);

}

else {

emit(node);

}

}

function emitComputedPropertyName(node: ComputedPropertyName) {

write("[");

emitExpression(node.expression);

write("]");

}

//

// Signature elements

//

function emitTypeParameter(node: TypeParameterDeclaration) {

emit(node.name);

emitWithPrefix(" extends ", node.constraint);

}

function emitParameter(node: ParameterDeclaration) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

writeIfPresent(node.dotDotDotToken, "...");

emit(node.name);

writeIfPresent(node.questionToken, "?");

emitExpressionWithPrefix(" = ", node.initializer);

emitWithPrefix(": ", node.type);

}

function emitDecorator(decorator: Decorator) {

write("@");

emitExpression(decorator.expression);

}

//

// Type members

//

function emitPropertySignature(node: PropertySignature) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emit(node.name);

writeIfPresent(node.questionToken, "?");

emitWithPrefix(": ", node.type);

write(";");

}

function emitPropertyDeclaration(node: PropertyDeclaration) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emit(node.name);

emitWithPrefix(": ", node.type);

emitExpressionWithPrefix(" = ", node.initializer);

write(";");

}

function emitMethodSignature(node: MethodSignature) {

emitDecorators(node, node.decorators);

emitModifiers(node, node.modifiers);

emit(node.name);

writeIfPresent(node.questionToken, "?");

emitTypeParameters(node, node.typeParameters);

emitParameters(node, node.parameters);