@tslite/printer 0.5.7 → 1.12.0

package/dist/emitter.js

@@ -0,0 +1,2751 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/emitter.ts: o namespace virou módulo ES, com os imports explícitos.
+import * as ts from "./_namespaces/ts.js";
+import { CharacterCodes, Debug, EmitFlags, EmitHint, GeneratedIdentifierFlags, NodeFlags, ScriptTarget, SymbolFlags, SyntaxKind, cast, computeLineStarts, createMap, createNode, createTextWriter, emitDetachedComments, emitNewLineBeforeLeadingCommentOfPosition, escapeJsxAttributeString, escapeLeadingUnderscores, escapeNonAsciiString, escapeString, findIndex, forEach, forEachLeadingCommentRange, forEachTrailingCommentRange, getCommentRange, getEmitFlags, getExternalModuleName, getLineStarts, getLinesBetweenPositionAndNextNonWhitespaceCharacter, getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter, getLinesBetweenRangeEndAndRangeStart, getLiteralText, getNewLineCharacter, getNodeId, getOriginalNode, getParseTreeNode, getShebang, getSourceFileOfNode, getSourceTextOfNodeFromSourceFile, getStartsOnNewLine, getSyntheticLeadingComments, getSyntheticTrailingComments, getTrailingSemicolonDeferringWriter, idText, isArrowFunction, isBinaryExpression, isBindingPattern, isBlock, isEmptyStatement, isExpression, isFunctionLike, isGeneratedIdentifier, isIdentifier, isJsonSourceFile, isJsxClosingElement, isJsxOpeningElement, isKeyword, isLet, isLiteralExpression, isNodeDescendantOf, isNumericLiteral, isPrologueDirective, isSourceFile, isStringLiteral, isTemplateLiteralKind, isToken, isTypeParameterDeclaration, isVarConst, last, lastOrUndefined, makeIdentifierFromModuleName, noEmitNotification, nodeIsSynthesized, positionIsSynthesized, positionsAreOnSameLine, rangeEndIsOnSameLineAsRangeStart, rangeEndPositionsAreOnSameLine, rangeIsOnSingleLine, rangeStartPositionsAreOnSameLine, singleOrUndefined, skipPartiallyEmittedExpressions, skipTrivia, some, stringContains, tokenToString, writeCommentRange, } from "./_namespaces/ts.js";
+const syntheticParent = { pos: -1, end: -1 };
+const brackets = createBracketsMap();
+var PipelinePhase;
+(function (PipelinePhase) {
+    PipelinePhase[PipelinePhase["Notification"] = 0] = "Notification";
+    PipelinePhase[PipelinePhase["Comments"] = 1] = "Comments";
+    PipelinePhase[PipelinePhase["Emit"] = 2] = "Emit";
+})(PipelinePhase || (PipelinePhase = {}));
+export function createPrinter(printerOptions = {}, handlers = {}) {
+    const { hasGlobalName, onEmitNode = noEmitNotification, isEmitNotificationEnabled, onBeforeEmitNodeArray, onAfterEmitNodeArray, onBeforeEmitToken, onAfterEmitToken } = handlers;
+    const newLine = getNewLineCharacter(printerOptions);
+    let currentSourceFile;
+    let nodeIdToGeneratedName; // Map of generated names for specific nodes.
+    let autoGeneratedIdToGeneratedName; // Map of generated names for temp and loop variables.
+    let generatedNames; // Set of names generated by the NameGenerator.
+    let tempFlagsStack; // Stack of enclosing name generation scopes.
+    let tempFlags; // TempFlags for the current name generation scope.
+    let reservedNamesStack; // Stack of TempFlags reserved in enclosing name generation scopes.
+    let reservedNames; // TempFlags to reserve in nested name generation scopes.
+    let preserveSourceNewlines = printerOptions.preserveSourceNewlines; // Can be overridden inside nodes with the `IgnoreSourceNewlines` emit flag.
+    let writer;
+    let ownWriter; // Reusable `EmitTextWriter` for basic printing.
+    let write = writeBase;
+    // Comments
+    let containerPos = -1;
+    let containerEnd = -1;
+    let declarationListContainerEnd = -1;
+    let currentLineMap;
+    let detachedCommentsInfo;
+    let hasWrittenComment = false;
+    let commentsDisabled = !!printerOptions.removeComments;
+    let lastNode;
+    reset();
+    return {
+        // public API
+        printNode,
+        printList,
+        printFile,
+        // internal API
+        writeNode,
+        writeList,
+        writeFile,
+    };
+    function printNode(hint, node, sourceFile) {
+        switch (hint) {
+            case EmitHint.SourceFile:
+                Debug.assert(isSourceFile(node), "Expected a SourceFile node.");
+                break;
+            case EmitHint.IdentifierName:
+                Debug.assert(isIdentifier(node), "Expected an Identifier node.");
+                break;
+            case EmitHint.Expression:
+                Debug.assert(isExpression(node), "Expected an Expression node.");
+                break;
+        }
+        switch (node.kind) {
+            case SyntaxKind.SourceFile: return printFile(node);
+        }
+        writeNode(hint, node, sourceFile, beginPrint());
+        return endPrint();
+    }
+    function printList(format, nodes, sourceFile) {
+        writeList(format, nodes, sourceFile, beginPrint());
+        return endPrint();
+    }
+    function printFile(sourceFile) {
+        writeFile(sourceFile, beginPrint());
+        return endPrint();
+    }
+    function writeNode(hint, node, sourceFile, output) {
+        const previousWriter = writer;
+        setWriter(output);
+        print(hint, node, sourceFile);
+        reset();
+        writer = previousWriter;
+    }
+    function writeList(format, nodes, sourceFile, output) {
+        const previousWriter = writer;
+        setWriter(output);
+        if (sourceFile) {
+            setSourceFile(sourceFile);
+        }
+        emitList(syntheticParent, nodes, format);
+        reset();
+        writer = previousWriter;
+    }
+    function writeFile(sourceFile, output) {
+        const previousWriter = writer;
+        setWriter(output);
+        emitShebangIfNeeded(sourceFile);
+        emitPrologueDirectivesIfNeeded(sourceFile);
+        print(EmitHint.SourceFile, sourceFile, sourceFile);
+        reset();
+        writer = previousWriter;
+    }
+    function beginPrint() {
+        return ownWriter || (ownWriter = createTextWriter(newLine));
+    }
+    function endPrint() {
+        const text = ownWriter.getText();
+        ownWriter.clear();
+        return text;
+    }
+    function print(hint, node, sourceFile) {
+        if (sourceFile) {
+            setSourceFile(sourceFile);
+        }
+        pipelineEmit(hint, node);
+    }
+    function setSourceFile(sourceFile) {
+        currentSourceFile = sourceFile;
+        currentLineMap = undefined;
+        detachedCommentsInfo = undefined;
+    }
+    function setWriter(_writer) {
+        if (_writer && printerOptions.omitTrailingSemicolon) {
+            _writer = getTrailingSemicolonDeferringWriter(_writer);
+        }
+        writer = _writer;
+    }
+    function reset() {
+        nodeIdToGeneratedName = [];
+        autoGeneratedIdToGeneratedName = [];
+        generatedNames = createMap();
+        tempFlagsStack = [];
+        tempFlags = 0 /* TempFlags.Auto */;
+        reservedNamesStack = [];
+        currentSourceFile = undefined;
+        currentLineMap = undefined;
+        detachedCommentsInfo = undefined;
+        lastNode = undefined;
+        setWriter(/*output*/ undefined);
+    }
+    function getCurrentLineMap() {
+        return currentLineMap || (currentLineMap = getLineStarts(currentSourceFile));
+    }
+    function emit(node) {
+        if (node === undefined)
+            return;
+        return pipelineEmit(EmitHint.Unspecified, node);
+    }
+    function emitExpression(node) {
+        if (node === undefined)
+            return;
+        return pipelineEmit(EmitHint.Expression, node);
+    }
+    function emitJsxAttributeValue(node) {
+        return pipelineEmit(isStringLiteral(node) ? EmitHint.JsxAttributeValue : EmitHint.Unspecified, node);
+    }
+    function pipelineEmit(emitHint, node) {
+        const savedLastNode = lastNode;
+        const savedPreserveSourceNewlines = preserveSourceNewlines;
+        lastNode = node;
+        if (preserveSourceNewlines && !!(getEmitFlags(node) & EmitFlags.IgnoreSourceNewlines)) {
+            preserveSourceNewlines = false;
+        }
+        const pipelinePhase = getPipelinePhase(0 /* PipelinePhase.Notification */, emitHint, node);
+        pipelinePhase(emitHint, node);
+        Debug.assert(lastNode === node);
+        lastNode = savedLastNode;
+        preserveSourceNewlines = savedPreserveSourceNewlines;
+        return node;
+    }
+    function getPipelinePhase(phase, _emitHint, node) {
+        switch (phase) {
+            case 0 /* PipelinePhase.Notification */:
+                if (onEmitNode !== noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) {
+                    return pipelineEmitWithNotification;
+                }
+            // falls through
+            case 1 /* PipelinePhase.Comments */:
+                if (!commentsDisabled && node.kind !== SyntaxKind.SourceFile) {
+                    return pipelineEmitWithComments;
+                }
+            // falls through
+            case 2 /* PipelinePhase.Emit */:
+                return pipelineEmitWithHint;
+            default:
+                return Debug.assertNever(phase);
+        }
+    }
+    function getNextPipelinePhase(currentPhase, emitHint, node) {
+        return getPipelinePhase(currentPhase + 1, emitHint, node);
+    }
+    function pipelineEmitWithNotification(hint, node) {
+        Debug.assert(lastNode === node);
+        const pipelinePhase = getNextPipelinePhase(0 /* PipelinePhase.Notification */, hint, node);
+        onEmitNode(hint, node, pipelinePhase);
+        Debug.assert(lastNode === node);
+    }
+    function pipelineEmitWithHint(hint, node) {
+        Debug.assert(lastNode === node);
+        if (hint === EmitHint.SourceFile)
+            return emitSourceFile(cast(node, isSourceFile));
+        if (hint === EmitHint.IdentifierName)
+            return emitIdentifier(cast(node, isIdentifier));
+        if (hint === EmitHint.JsxAttributeValue)
+            return emitLiteral(cast(node, isStringLiteral), /*jsxAttributeEscape*/ true);
+        if (hint === EmitHint.MappedTypeParameter)
+            return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
+        if (hint === EmitHint.EmbeddedStatement) {
+            Debug.assertNode(node, isEmptyStatement);
+            return emitEmptyStatement(/*isEmbeddedStatement*/ true);
+        }
+        if (hint === EmitHint.Unspecified) {
+            if (isKeyword(node.kind))
+                return writeTokenNode(node, writeKeyword);
+            switch (node.kind) {
+                // Pseudo-literals
+                case SyntaxKind.TemplateHead:
+                case SyntaxKind.TemplateMiddle:
+                case SyntaxKind.TemplateTail:
+                    return emitLiteral(node, /*jsxAttributeEscape*/ false);
+                // Identifiers
+                case SyntaxKind.Identifier:
+                    return emitIdentifier(node);
+                // Parse tree nodes
+                // Names
+                case SyntaxKind.QualifiedName:
+                    return emitQualifiedName(node);
+                case SyntaxKind.ComputedPropertyName:
+                    return emitComputedPropertyName(node);
+                // Signature elements
+                case SyntaxKind.TypeParameter:
+                    return emitTypeParameter(node);
+                case SyntaxKind.Parameter:
+                    return emitParameter(node);
+                // Type members
+                case SyntaxKind.PropertySignature:
+                    return emitPropertySignature(node);
+                case SyntaxKind.MethodSignature:
+                    return emitMethodSignature(node);
+                case SyntaxKind.CallSignature:
+                    return emitCallSignature(node);
+                case SyntaxKind.IndexSignature:
+                    return emitIndexSignature(node);
+                // Types
+                case SyntaxKind.TypePredicate:
+                    return emitTypePredicate(node);
+                case SyntaxKind.TypeReference:
+                    return emitTypeReference(node);
+                case SyntaxKind.FunctionType:
+                    return emitFunctionType(node);
+                case SyntaxKind.TypeQuery:
+                    return emitTypeQuery(node);
+                case SyntaxKind.TypeLiteral:
+                    return emitTypeLiteral(node);
+                case SyntaxKind.ArrayType:
+                    return emitArrayType(node);
+                case SyntaxKind.TupleType:
+                    return emitTupleType(node);
+                case SyntaxKind.OptionalType:
+                    return emitOptionalType(node);
+                case SyntaxKind.UnionType:
+                    return emitUnionType(node);
+                case SyntaxKind.IntersectionType:
+                    return emitIntersectionType(node);
+                case SyntaxKind.ConditionalType:
+                    return emitConditionalType(node);
+                case SyntaxKind.InferType:
+                    return emitInferType(node);
+                case SyntaxKind.ParenthesizedType:
+                    return emitParenthesizedType(node);
+                case SyntaxKind.TypeOperator:
+                    return emitTypeOperator(node);
+                case SyntaxKind.IndexedAccessType:
+                    return emitIndexedAccessType(node);
+                case SyntaxKind.MappedType:
+                    return emitMappedType(node);
+                case SyntaxKind.LiteralType:
+                    return emitLiteralType(node);
+                case SyntaxKind.ImportType:
+                    return emitImportTypeNode(node);
+                case SyntaxKind.RestType:
+                    return emitRestOrJSDocVariadicType(node);
+                // Binding patterns
+                case SyntaxKind.ObjectBindingPattern:
+                    return emitObjectBindingPattern(node);
+                case SyntaxKind.ArrayBindingPattern:
+                    return emitArrayBindingPattern(node);
+                case SyntaxKind.BindingElement:
+                    return emitBindingElement(node);
+                // Misc
+                case SyntaxKind.TemplateSpan:
+                    return emitTemplateSpan(node);
+                // Statements
+                case SyntaxKind.Block:
+                    return emitBlock(node);
+                case SyntaxKind.VariableStatement:
+                    return emitVariableStatement(node);
+                case SyntaxKind.EmptyStatement:
+                    return emitEmptyStatement(/*isEmbeddedStatement*/ false);
+                case SyntaxKind.ExpressionStatement:
+                    return emitExpressionStatement(node);
+                case SyntaxKind.IfStatement:
+                    return emitIfStatement(node);
+                case SyntaxKind.DoStatement:
+                    return emitDoStatement(node);
+                case SyntaxKind.WhileStatement:
+                    return emitWhileStatement(node);
+                case SyntaxKind.ForStatement:
+                    return emitForStatement(node);
+                case SyntaxKind.ForInStatement:
+                    return emitForInStatement(node);
+                case SyntaxKind.ForOfStatement:
+                    return emitForOfStatement(node);
+                case SyntaxKind.ContinueStatement:
+                    return emitContinueStatement(node);
+                case SyntaxKind.BreakStatement:
+                    return emitBreakStatement(node);
+                case SyntaxKind.ReturnStatement:
+                    return emitReturnStatement(node);
+                case SyntaxKind.SwitchStatement:
+                    return emitSwitchStatement(node);
+                case SyntaxKind.ThrowStatement:
+                    return emitThrowStatement(node);
+                case SyntaxKind.TryStatement:
+                    return emitTryStatement(node);
+                // Declarations
+                case SyntaxKind.VariableDeclaration:
+                    return emitVariableDeclaration(node);
+                case SyntaxKind.VariableDeclarationList:
+                    return emitVariableDeclarationList(node);
+                case SyntaxKind.TypeAliasDeclaration:
+                    return emitTypeAliasDeclaration(node);
+                case SyntaxKind.ModuleDeclaration:
+                    return emitModuleDeclaration(node);
+                case SyntaxKind.ModuleBlock:
+                    return emitModuleBlock(node);
+                case SyntaxKind.CaseBlock:
+                    return emitCaseBlock(node);
+                case SyntaxKind.ImportDeclaration:
+                    return emitImportDeclaration(node);
+                case SyntaxKind.ImportClause:
+                    return emitImportClause(node);
+                case SyntaxKind.NamespaceImport:
+                    return emitNamespaceImport(node);
+                case SyntaxKind.NamespaceExport:
+                    return emitNamespaceExport(node);
+                case SyntaxKind.NamedImports:
+                    return emitNamedImports(node);
+                case SyntaxKind.ImportSpecifier:
+                    return emitImportSpecifier(node);
+                case SyntaxKind.ExportAssignment:
+                    return emitExportAssignment(node);
+                case SyntaxKind.ExportDeclaration:
+                    return emitExportDeclaration(node);
+                case SyntaxKind.NamedExports:
+                    return emitNamedExports(node);
+                case SyntaxKind.ExportSpecifier:
+                    return emitExportSpecifier(node);
+                case SyntaxKind.MissingDeclaration:
+                    return;
+                // JSX (non-expression)
+                case SyntaxKind.JsxText:
+                    return emitJsxText(node);
+                case SyntaxKind.JsxOpeningElement:
+                case SyntaxKind.JsxOpeningFragment:
+                    return emitJsxOpeningElementOrFragment(node);
+                case SyntaxKind.JsxClosingElement:
+                case SyntaxKind.JsxClosingFragment:
+                    return emitJsxClosingElementOrFragment(node);
+                case SyntaxKind.JsxAttribute:
+                    return emitJsxAttribute(node);
+                case SyntaxKind.JsxAttributes:
+                    return emitJsxAttributes(node);
+                case SyntaxKind.JsxSpreadAttribute:
+                    return emitJsxSpreadAttribute(node);
+                case SyntaxKind.JsxExpression:
+                    return emitJsxExpression(node);
+                // Clauses
+                case SyntaxKind.CaseClause:
+                    return emitCaseClause(node);
+                case SyntaxKind.DefaultClause:
+                    return emitDefaultClause(node);
+                case SyntaxKind.CatchClause:
+                    return emitCatchClause(node);
+                // Property assignments
+                case SyntaxKind.PropertyAssignment:
+                    return emitPropertyAssignment(node);
+                case SyntaxKind.ShorthandPropertyAssignment:
+                    return emitShorthandPropertyAssignment(node);
+                case SyntaxKind.SpreadAssignment:
+                    return emitSpreadAssignment(node);
+                // Transformation nodes (ignored)
+            }
+            if (isExpression(node)) {
+                hint = EmitHint.Expression;
+            }
+            else if (isToken(node)) {
+                return writeTokenNode(node, writePunctuation);
+            }
+        }
+        if (hint === EmitHint.Expression) {
+            switch (node.kind) {
+                // Literals
+                case SyntaxKind.NumericLiteral:
+                case SyntaxKind.BigIntLiteral:
+                    return emitNumericOrBigIntLiteral(node);
+                case SyntaxKind.StringLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
+                    return emitLiteral(node, /*jsxAttributeEscape*/ false);
+                // Identifiers
+                case SyntaxKind.Identifier:
+                    return emitIdentifier(node);
+                // Reserved words
+                case SyntaxKind.FalseKeyword:
+                case SyntaxKind.NullKeyword:
+                case SyntaxKind.TrueKeyword:
+                case SyntaxKind.ImportKeyword:
+                    writeTokenNode(node, writeKeyword);
+                    return;
+                // Expressions
+                case SyntaxKind.ArrayLiteralExpression:
+                    return emitArrayLiteralExpression(node);
+                case SyntaxKind.ObjectLiteralExpression:
+                    return emitObjectLiteralExpression(node);
+                case SyntaxKind.PropertyAccessExpression:
+                    return emitPropertyAccessExpression(node);
+                case SyntaxKind.ElementAccessExpression:
+                    return emitElementAccessExpression(node);
+                case SyntaxKind.CallExpression:
+                    return emitCallExpression(node);
+                case SyntaxKind.ParenthesizedExpression:
+                    return emitParenthesizedExpression(node);
+                case SyntaxKind.ArrowFunction:
+                    return emitArrowFunction(node);
+                case SyntaxKind.DeleteExpression:
+                    return emitDeleteExpression(node);
+                case SyntaxKind.TypeOfExpression:
+                    return emitTypeOfExpression(node);
+                case SyntaxKind.AwaitExpression:
+                    return emitAwaitExpression(node);
+                case SyntaxKind.PrefixUnaryExpression:
+                    return emitPrefixUnaryExpression(node);
+                case SyntaxKind.PostfixUnaryExpression:
+                    return emitPostfixUnaryExpression(node);
+                case SyntaxKind.BinaryExpression:
+                    return emitBinaryExpression(node);
+                case SyntaxKind.ConditionalExpression:
+                    return emitConditionalExpression(node);
+                case SyntaxKind.TemplateExpression:
+                    return emitTemplateExpression(node);
+                case SyntaxKind.SpreadElement:
+                    return emitSpreadExpression(node);
+                case SyntaxKind.OmittedExpression:
+                    return;
+                case SyntaxKind.AsExpression:
+                    return emitAsExpression(node);
+                case SyntaxKind.MetaProperty:
+                    return emitMetaProperty(node);
+                // JSX
+                case SyntaxKind.JsxElement:
+                    return emitJsxElement(node);
+                case SyntaxKind.JsxSelfClosingElement:
+                    return emitJsxSelfClosingElement(node);
+                case SyntaxKind.JsxFragment:
+                    return emitJsxFragment(node);
+            }
+        }
+    }
+    function emitMappedTypeParameter(node) {
+        emit(node.name);
+        writeSpace();
+        writeKeyword("in");
+        writeSpace();
+        emit(node.constraint);
+    }
+    //
+    // Literals/Pseudo-literals
+    //
+    // SyntaxKind.NumericLiteral
+    // SyntaxKind.BigIntLiteral
+    function emitNumericOrBigIntLiteral(node) {
+        emitLiteral(node, /*jsxAttributeEscape*/ false);
+    }
+    // SyntaxKind.StringLiteral
+    // SyntaxKind.NoSubstitutionTemplateLiteral
+    // SyntaxKind.TemplateHead
+    // SyntaxKind.TemplateMiddle
+    // SyntaxKind.TemplateTail
+    function emitLiteral(node, jsxAttributeEscape) {
+        const text = getLiteralTextOfNode(node, printerOptions.neverAsciiEscape, jsxAttributeEscape);
+        if ((printerOptions.sourceMap || printerOptions.inlineSourceMap)
+            && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
+            writeLiteral(text);
+        }
+        else {
+            // Quick info expects all literals to be called with writeStringLiteral, as there's no specific type for numberLiterals
+            writeStringLiteral(text);
+        }
+    }
+    //
+    // Identifiers
+    //
+    function emitIdentifier(node) {
+        const writeText = node.symbol ? writeSymbol : write;
+        writeText(getTextOfNode(node, /*includeTrivia*/ false), node.symbol);
+        emitList(node, node.typeArguments, 53776 /* ListFormat.TypeParameters */); // Call emitList directly since it could be an array of TypeParameterDeclarations _or_ type arguments
+    }
+    //
+    // Names
+    //
+    function emitQualifiedName(node) {
+        emitEntityName(node.left);
+        writePunctuation(".");
+        emit(node.right);
+    }
+    function emitEntityName(node) {
+        if (node.kind === SyntaxKind.Identifier) {
+            emitExpression(node);
+        }
+        else {
+            emit(node);
+        }
+    }
+    function emitComputedPropertyName(node) {
+        writePunctuation("[");
+        emitExpression(node.expression);
+        writePunctuation("]");
+    }
+    //
+    // Signature elements
+    //
+    function emitTypeParameter(node) {
+        emit(node.name);
+        if (node.constraint) {
+            writeSpace();
+            writeKeyword("extends");
+            writeSpace();
+            emit(node.constraint);
+        }
+        if (node.default) {
+            writeSpace();
+            writeOperator("=");
+            writeSpace();
+            emit(node.default);
+        }
+    }
+    function emitParameter(node) {
+        emitModifiers(node, node.modifiers);
+        emit(node.dotDotDotToken);
+        emitNodeWithWriter(node.name, writeParameter);
+        emit(node.questionToken);
+        emitTypeAnnotation(node.type);
+        // The comment position has to fallback to any present node within the parameterdeclaration because as it turns out, the parser can make parameter declarations with _just_ an initializer.
+        emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name ? node.name.end : node.modifiers ? node.modifiers.end : node.pos, node);
+    }
+    //
+    // Type members
+    //
+    function emitPropertySignature(node) {
+        emitModifiers(node, node.modifiers);
+        emitNodeWithWriter(node.name, writeProperty);
+        emit(node.questionToken);
+        emitTypeAnnotation(node.type);
+        writeTrailingSemicolon();
+    }
+    function emitMethodSignature(node) {
+        pushNameGenerationScope(node);
+        emitModifiers(node, node.modifiers);
+        emit(node.name);
+        emit(node.questionToken);
+        emitTypeParameters(node, node.typeParameters);
+        emitParameters(node, node.parameters);
+        emitTypeAnnotation(node.type);
+        writeTrailingSemicolon();
+        popNameGenerationScope(node);
+    }
+    function emitCallSignature(node) {
+        pushNameGenerationScope(node);
+        emitModifiers(node, node.modifiers);
+        emitTypeParameters(node, node.typeParameters);
+        emitParameters(node, node.parameters);
+        emitTypeAnnotation(node.type);
+        writeTrailingSemicolon();
+        popNameGenerationScope(node);
+    }
+    function emitIndexSignature(node) {
+        emitModifiers(node, node.modifiers);
+        emitParametersForIndexSignature(node, node.parameters);
+        emitTypeAnnotation(node.type);
+        writeTrailingSemicolon();
+    }
+    //
+    // Types
+    //
+    function emitTypePredicate(node) {
+        if (node.assertsModifier) {
+            emit(node.assertsModifier);
+            writeSpace();
+        }
+        emit(node.parameterName);
+        if (node.type) {
+            writeSpace();
+            writeKeyword("is");
+            writeSpace();
+            emit(node.type);
+        }
+    }
+    function emitTypeReference(node) {
+        emit(node.typeName);
+        emitTypeArguments(node, node.typeArguments);
+    }
+    function emitFunctionType(node) {
+        pushNameGenerationScope(node);
+        emitTypeParameters(node, node.typeParameters);
+        emitParametersForArrow(node, node.parameters);
+        writeSpace();
+        writePunctuation("=>");
+        writeSpace();
+        emit(node.type);
+        popNameGenerationScope(node);
+    }
+    function emitTypeQuery(node) {
+        writeKeyword("typeof");
+        writeSpace();
+        emit(node.exprName);
+    }
+    function emitTypeLiteral(node) {
+        writePunctuation("{");
+        const flags = getEmitFlags(node) & EmitFlags.SingleLine ? 768 /* ListFormat.SingleLineTypeLiteralMembers */ : 32897 /* ListFormat.MultiLineTypeLiteralMembers */;
+        emitList(node, node.members, flags | 524288 /* ListFormat.NoSpaceIfEmpty */);
+        writePunctuation("}");
+    }
+    function emitArrayType(node) {
+        emit(node.elementType);
+        writePunctuation("[");
+        writePunctuation("]");
+    }
+    function emitRestOrJSDocVariadicType(node) {
+        writePunctuation("...");
+        emit(node.type);
+    }
+    function emitTupleType(node) {
+        writePunctuation("[");
+        emitList(node, node.elementTypes, 528 /* ListFormat.TupleTypeElements */);
+        writePunctuation("]");
+    }
+    function emitOptionalType(node) {
+        emit(node.type);
+        writePunctuation("?");
+    }
+    function emitUnionType(node) {
+        emitList(node, node.types, 516 /* ListFormat.UnionTypeConstituents */);
+    }
+    function emitIntersectionType(node) {
+        emitList(node, node.types, 520 /* ListFormat.IntersectionTypeConstituents */);
+    }
+    function emitConditionalType(node) {
+        emit(node.checkType);
+        writeSpace();
+        writeKeyword("extends");
+        writeSpace();
+        emit(node.extendsType);
+        writeSpace();
+        writePunctuation("?");
+        writeSpace();
+        emit(node.trueType);
+        writeSpace();
+        writePunctuation(":");
+        writeSpace();
+        emit(node.falseType);
+    }
+    function emitInferType(node) {
+        writeKeyword("infer");
+        writeSpace();
+        emit(node.typeParameter);
+    }
+    function emitParenthesizedType(node) {
+        writePunctuation("(");
+        emit(node.type);
+        writePunctuation(")");
+    }
+    function emitTypeOperator(node) {
+        writeTokenText(node.operator, writeKeyword);
+        writeSpace();
+        emit(node.type);
+    }
+    function emitIndexedAccessType(node) {
+        emit(node.objectType);
+        writePunctuation("[");
+        emit(node.indexType);
+        writePunctuation("]");
+    }
+    function emitMappedType(node) {
+        const emitFlags = getEmitFlags(node);
+        writePunctuation("{");
+        if (emitFlags & EmitFlags.SingleLine) {
+            writeSpace();
+        }
+        else {
+            writeLine();
+            increaseIndent();
+        }
+        if (node.readonlyToken) {
+            emit(node.readonlyToken);
+            if (node.readonlyToken.kind !== SyntaxKind.ReadonlyKeyword) {
+                writeKeyword("readonly");
+            }
+            writeSpace();
+        }
+        writePunctuation("[");
+        pipelineEmit(EmitHint.MappedTypeParameter, node.typeParameter);
+        writePunctuation("]");
+        if (node.questionToken) {
+            emit(node.questionToken);
+            if (node.questionToken.kind !== SyntaxKind.QuestionToken) {
+                writePunctuation("?");
+            }
+        }
+        writePunctuation(":");
+        writeSpace();
+        emit(node.type);
+        writeTrailingSemicolon();
+        if (emitFlags & EmitFlags.SingleLine) {
+            writeSpace();
+        }
+        else {
+            writeLine();
+            decreaseIndent();
+        }
+        writePunctuation("}");
+    }
+    function emitLiteralType(node) {
+        emitExpression(node.literal);
+    }
+    function emitImportTypeNode(node) {
+        if (node.isTypeOf) {
+            writeKeyword("typeof");
+            writeSpace();
+        }
+        writeKeyword("import");
+        writePunctuation("(");
+        emit(node.argument);
+        writePunctuation(")");
+        if (node.qualifier) {
+            writePunctuation(".");
+            emit(node.qualifier);
+        }
+        emitTypeArguments(node, node.typeArguments);
+    }
+    //
+    // Binding patterns
+    //
+    function emitObjectBindingPattern(node) {
+        writePunctuation("{");
+        emitList(node, node.elements, 525136 /* ListFormat.ObjectBindingPatternElements */);
+        writePunctuation("}");
+    }
+    function emitArrayBindingPattern(node) {
+        writePunctuation("[");
+        emitList(node, node.elements, 524880 /* ListFormat.ArrayBindingPatternElements */);
+        writePunctuation("]");
+    }
+    function emitBindingElement(node) {
+        emit(node.dotDotDotToken);
+        if (node.propertyName) {
+            emit(node.propertyName);
+            writePunctuation(":");
+            writeSpace();
+        }
+        emit(node.name);
+        emitInitializer(node.initializer, node.name.end, node);
+    }
+    //
+    // Expressions
+    //
+    function emitArrayLiteralExpression(node) {
+        const elements = node.elements;
+        const preferNewLine = node.multiLine ? 65536 /* ListFormat.PreferNewLine */ : 0 /* ListFormat.None */;
+        emitExpressionList(node, elements, 8914 /* ListFormat.ArrayLiteralExpressionElements */ | preferNewLine);
+    }
+    function emitObjectLiteralExpression(node) {
+        forEach(node.properties, generateMemberNames);
+        const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+        if (indentedFlag) {
+            increaseIndent();
+        }
+        const preferNewLine = node.multiLine ? 65536 /* ListFormat.PreferNewLine */ : 0 /* ListFormat.None */;
+        const allowTrailingComma = currentSourceFile.languageVersion >= ScriptTarget.ES5 && !isJsonSourceFile(currentSourceFile) ? 64 /* ListFormat.AllowTrailingComma */ : 0 /* ListFormat.None */;
+        emitList(node, node.properties, 526226 /* ListFormat.ObjectLiteralExpressionProperties */ | allowTrailingComma | preferNewLine);
+        if (indentedFlag) {
+            decreaseIndent();
+        }
+    }
+    function emitPropertyAccessExpression(node) {
+        const expression = cast(emitExpression(node.expression), isExpression);
+        const token = node.questionDotToken || createNode(SyntaxKind.DotToken, node.expression.end, node.name.pos);
+        const linesBeforeDot = getLinesBetweenNodes(node, node.expression, token);
+        const linesAfterDot = getLinesBetweenNodes(node, token, node.name);
+        writeLinesAndIndent(linesBeforeDot, /*writeSpaceIfNotIndenting*/ false);
+        const shouldEmitDotDot = token.kind !== SyntaxKind.QuestionDotToken &&
+            mayNeedDotDotForPropertyAccess(expression) &&
+            !writer.hasTrailingComment() &&
+            !writer.hasTrailingWhitespace();
+        if (shouldEmitDotDot) {
+            writePunctuation(".");
+        }
+        if (node.questionDotToken) {
+            emit(token);
+        }
+        else {
+            emitTokenWithComment(token.kind, node.expression.end, writePunctuation, node);
+        }
+        writeLinesAndIndent(linesAfterDot, /*writeSpaceIfNotIndenting*/ false);
+        emit(node.name);
+        decreaseIndentIf(linesBeforeDot, linesAfterDot);
+    }
+    // `1..toString` é um acesso válido: o literal inteiro, impresso como foi escrito e sem ponto, precisa de um segundo
+    // ponto antes do acesso.
+    function mayNeedDotDotForPropertyAccess(expression) {
+        expression = skipPartiallyEmittedExpressions(expression);
+        if (isNumericLiteral(expression)) {
+            const text = getLiteralTextOfNode(expression, /*neverAsciiEscape*/ true, /*jsxAttributeEscape*/ false);
+            return !expression.numericLiteralFlags && !stringContains(text, tokenToString(SyntaxKind.DotToken));
+        }
+    }
+    function emitElementAccessExpression(node) {
+        emitExpression(node.expression);
+        emit(node.questionDotToken);
+        emitTokenWithComment(SyntaxKind.OpenBracketToken, node.expression.end, writePunctuation, node);
+        emitExpression(node.argumentExpression);
+        emitTokenWithComment(SyntaxKind.CloseBracketToken, node.argumentExpression.end, writePunctuation, node);
+    }
+    function emitCallExpression(node) {
+        emitExpression(node.expression);
+        emit(node.questionDotToken);
+        emitTypeArguments(node, node.typeArguments);
+        emitExpressionList(node, node.arguments, 2576 /* ListFormat.CallExpressionArguments */);
+    }
+    function emitParenthesizedExpression(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.OpenParenToken, node.pos, writePunctuation, node);
+        const indented = writeLineSeparatorsAndIndentBefore(node.expression, node);
+        emitExpression(node.expression);
+        writeLineSeparatorsAfter(node.expression, node);
+        decreaseIndentIf(indented);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.expression ? node.expression.end : openParenPos, writePunctuation, node);
+    }
+    function emitArrowFunction(node) {
+        emitModifiers(node, node.modifiers);
+        emitSignatureAndBody(node, emitArrowFunctionHead);
+    }
+    function emitArrowFunctionHead(node) {
+        emitTypeParameters(node, node.typeParameters);
+        emitParametersForArrow(node, node.parameters);
+        emitTypeAnnotation(node.type);
+        writeSpace();
+        emit(node.equalsGreaterThanToken);
+    }
+    function emitDeleteExpression(node) {
+        emitTokenWithComment(SyntaxKind.DeleteKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+    }
+    function emitTypeOfExpression(node) {
+        emitTokenWithComment(SyntaxKind.TypeOfKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+    }
+    function emitAwaitExpression(node) {
+        emitTokenWithComment(SyntaxKind.AwaitKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+    }
+    function emitPrefixUnaryExpression(node) {
+        writeTokenText(node.operator, writeOperator);
+        if (shouldEmitWhitespaceBeforeOperand(node)) {
+            writeSpace();
+        }
+        emitExpression(node.operand);
+    }
+    function shouldEmitWhitespaceBeforeOperand(node) {
+        // In some cases, we need to emit a space between the operator and the operand. One obvious case
+        // is when the operator is an identifier, like delete or typeof. We also need to do this for plus
+        // and minus expressions in certain cases. Specifically, consider the following two cases (parens
+        // are just for clarity of exposition, and not part of the source code):
+        //
+        //  (+(+1))
+        //  (+(++1))
+        //
+        // We need to emit a space in both cases. In the first case, the absence of a space will make
+        // the resulting expression a prefix increment operation. And in the second, it will make the resulting
+        // expression a prefix increment whose operand is a plus expression - (++(+x))
+        // The same is true of minus of course.
+        const operand = node.operand;
+        return operand.kind === SyntaxKind.PrefixUnaryExpression
+            && ((node.operator === SyntaxKind.PlusToken && (operand.operator === SyntaxKind.PlusToken || operand.operator === SyntaxKind.PlusPlusToken))
+                || (node.operator === SyntaxKind.MinusToken && (operand.operator === SyntaxKind.MinusToken || operand.operator === SyntaxKind.MinusMinusToken)));
+    }
+    function emitPostfixUnaryExpression(node) {
+        emitExpression(node.operand);
+        writeTokenText(node.operator, writeOperator);
+    }
+    let EmitBinaryExpressionState;
+    (function (EmitBinaryExpressionState) {
+        EmitBinaryExpressionState[EmitBinaryExpressionState["EmitLeft"] = 0] = "EmitLeft";
+        EmitBinaryExpressionState[EmitBinaryExpressionState["EmitRight"] = 1] = "EmitRight";
+        EmitBinaryExpressionState[EmitBinaryExpressionState["FinishEmit"] = 2] = "FinishEmit";
+    })(EmitBinaryExpressionState || (EmitBinaryExpressionState = {}));
+    /**
+     * emitBinaryExpression includes an embedded work stack to attempt to handle as many nested binary expressions
+     * as possible without creating any additional stack frames. This can only be done when the emit pipeline does
+     * not require notification/substitution/comment/sourcemap decorations.
+     */
+    function emitBinaryExpression(node) {
+        const nodeStack = [node];
+        const stateStack = [0 /* EmitBinaryExpressionState.EmitLeft */];
+        let stackIndex = 0;
+        while (stackIndex >= 0) {
+            node = nodeStack[stackIndex];
+            switch (stateStack[stackIndex]) {
+                case 0 /* EmitBinaryExpressionState.EmitLeft */: {
+                    maybePipelineEmitExpression(node.left);
+                    break;
+                }
+                case 1 /* EmitBinaryExpressionState.EmitRight */: {
+                    const isCommaOperator = node.operatorToken.kind !== SyntaxKind.CommaToken;
+                    const linesBeforeOperator = getLinesBetweenNodes(node, node.left, node.operatorToken);
+                    const linesAfterOperator = getLinesBetweenNodes(node, node.operatorToken, node.right);
+                    writeLinesAndIndent(linesBeforeOperator, isCommaOperator);
+                    emitLeadingCommentsOfPosition(node.operatorToken.pos);
+                    writeTokenNode(node.operatorToken, node.operatorToken.kind === SyntaxKind.InKeyword ? writeKeyword : writeOperator);
+                    emitTrailingCommentsOfPosition(node.operatorToken.end, /*prefixSpace*/ true); // Binary operators should have a space before the comment starts
+                    writeLinesAndIndent(linesAfterOperator, /*writeSpaceIfNotIndenting*/ true);
+                    maybePipelineEmitExpression(node.right);
+                    break;
+                }
+                case 2 /* EmitBinaryExpressionState.FinishEmit */: {
+                    const linesBeforeOperator = getLinesBetweenNodes(node, node.left, node.operatorToken);
+                    const linesAfterOperator = getLinesBetweenNodes(node, node.operatorToken, node.right);
+                    decreaseIndentIf(linesBeforeOperator, linesAfterOperator);
+                    stackIndex--;
+                    break;
+                }
+                default: return Debug.fail(`Invalid state ${stateStack[stackIndex]} for emitBinaryExpressionWorker`);
+            }
+        }
+        function maybePipelineEmitExpression(next) {
+            // Advance the state of this unit of work,
+            stateStack[stackIndex]++;
+            // Then actually do the work of emitting the node `next` returned by the prior state
+            // The following section should be identical to `pipelineEmit` save it assumes EmitHint.Expression and offloads
+            // binary expression handling, where possible, to the contained work queue
+            // #region trampolinePipelineEmit
+            const savedLastNode = lastNode;
+            lastNode = next;
+            const pipelinePhase = getPipelinePhase(0 /* PipelinePhase.Notification */, EmitHint.Expression, next);
+            if (pipelinePhase === pipelineEmitWithHint && isBinaryExpression(next)) {
+                // If the target pipeline phase is emit directly, and the next node's also a binary expression,
+                // skip all the intermediate indirection and push the expression directly onto the work stack
+                stackIndex++;
+                stateStack[stackIndex] = 0 /* EmitBinaryExpressionState.EmitLeft */;
+                nodeStack[stackIndex] = next;
+            }
+            else {
+                pipelinePhase(EmitHint.Expression, next);
+            }
+            Debug.assert(lastNode === next);
+            lastNode = savedLastNode;
+            // #endregion trampolinePipelineEmit
+        }
+    }
+    function emitConditionalExpression(node) {
+        const linesBeforeQuestion = getLinesBetweenNodes(node, node.condition, node.questionToken);
+        const linesAfterQuestion = getLinesBetweenNodes(node, node.questionToken, node.whenTrue);
+        const linesBeforeColon = getLinesBetweenNodes(node, node.whenTrue, node.colonToken);
+        const linesAfterColon = getLinesBetweenNodes(node, node.colonToken, node.whenFalse);
+        emitExpression(node.condition);
+        writeLinesAndIndent(linesBeforeQuestion, /*writeSpaceIfNotIndenting*/ true);
+        emit(node.questionToken);
+        writeLinesAndIndent(linesAfterQuestion, /*writeSpaceIfNotIndenting*/ true);
+        emitExpression(node.whenTrue);
+        decreaseIndentIf(linesBeforeQuestion, linesAfterQuestion);
+        writeLinesAndIndent(linesBeforeColon, /*writeSpaceIfNotIndenting*/ true);
+        emit(node.colonToken);
+        writeLinesAndIndent(linesAfterColon, /*writeSpaceIfNotIndenting*/ true);
+        emitExpression(node.whenFalse);
+        decreaseIndentIf(linesBeforeColon, linesAfterColon);
+    }
+    function emitTemplateExpression(node) {
+        emit(node.head);
+        emitList(node, node.templateSpans, 262144 /* ListFormat.TemplateExpressionSpans */);
+    }
+    function emitSpreadExpression(node) {
+        emitTokenWithComment(SyntaxKind.DotDotDotToken, node.pos, writePunctuation, node);
+        emitExpression(node.expression);
+    }
+    function emitAsExpression(node) {
+        emitExpression(node.expression);
+        if (node.type) {
+            writeSpace();
+            writeKeyword("as");
+            writeSpace();
+            emit(node.type);
+        }
+    }
+    function emitMetaProperty(node) {
+        writeToken(node.keywordToken, node.pos, writePunctuation);
+        writePunctuation(".");
+        emit(node.name);
+    }
+    //
+    // Misc
+    //
+    function emitTemplateSpan(node) {
+        emitExpression(node.expression);
+        emit(node.literal);
+    }
+    //
+    // Statements
+    //
+    function emitBlock(node) {
+        emitBlockStatements(node, /*forceSingleLine*/ !node.multiLine && isEmptyBlock(node));
+    }
+    function emitBlockStatements(node, forceSingleLine) {
+        emitTokenWithComment(SyntaxKind.OpenBraceToken, node.pos, writePunctuation, /*contextNode*/ node);
+        const format = forceSingleLine || getEmitFlags(node) & EmitFlags.SingleLine ? 768 /* ListFormat.SingleLineBlockStatements */ : 129 /* ListFormat.MultiLineBlockStatements */;
+        emitList(node, node.statements, format);
+        emitTokenWithComment(SyntaxKind.CloseBraceToken, node.statements.end, writePunctuation, /*contextNode*/ node, /*indentLeading*/ !!(format & 1 /* ListFormat.MultiLine */));
+    }
+    function emitVariableStatement(node) {
+        emitModifiers(node, node.modifiers);
+        emit(node.declarationList);
+        writeTrailingSemicolon();
+    }
+    function emitEmptyStatement(isEmbeddedStatement) {
+        // While most trailing semicolons are possibly insignificant, an embedded "empty"
+        // statement is significant and cannot be elided by a trailing-semicolon-omitting writer.
+        if (isEmbeddedStatement) {
+            writePunctuation(";");
+        }
+        else {
+            writeTrailingSemicolon();
+        }
+    }
+    function emitExpressionStatement(node) {
+        emitExpression(node.expression);
+        // Emit semicolon in non json files
+        // or if json file that created synthesized expression(eg.define expression statement when --out and amd code generation)
+        if (!isJsonSourceFile(currentSourceFile) || nodeIsSynthesized(node.expression)) {
+            writeTrailingSemicolon();
+        }
+    }
+    function emitIfStatement(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.IfKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, node);
+        emitExpression(node.expression);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.expression.end, writePunctuation, node);
+        emitEmbeddedStatement(node, node.thenStatement);
+        if (node.elseStatement) {
+            writeLineOrSpace(node);
+            emitTokenWithComment(SyntaxKind.ElseKeyword, node.thenStatement.end, writeKeyword, node);
+            if (node.elseStatement.kind === SyntaxKind.IfStatement) {
+                writeSpace();
+                emit(node.elseStatement);
+            }
+            else {
+                emitEmbeddedStatement(node, node.elseStatement);
+            }
+        }
+    }
+    function emitWhileClause(node, startPos) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.WhileKeyword, startPos, writeKeyword, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, node);
+        emitExpression(node.expression);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.expression.end, writePunctuation, node);
+    }
+    function emitDoStatement(node) {
+        emitTokenWithComment(SyntaxKind.DoKeyword, node.pos, writeKeyword, node);
+        emitEmbeddedStatement(node, node.statement);
+        if (isBlock(node.statement)) {
+            writeSpace();
+        }
+        else {
+            writeLineOrSpace(node);
+        }
+        emitWhileClause(node, node.statement.end);
+        writeTrailingSemicolon();
+    }
+    function emitWhileStatement(node) {
+        emitWhileClause(node, node.pos);
+        emitEmbeddedStatement(node, node.statement);
+    }
+    function emitForStatement(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.ForKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        let pos = emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, /*contextNode*/ node);
+        emitForBinding(node.initializer);
+        pos = emitTokenWithComment(SyntaxKind.SemicolonToken, node.initializer ? node.initializer.end : pos, writePunctuation, node);
+        emitExpressionWithLeadingSpace(node.condition);
+        pos = emitTokenWithComment(SyntaxKind.SemicolonToken, node.condition ? node.condition.end : pos, writePunctuation, node);
+        emitExpressionWithLeadingSpace(node.incrementor);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.incrementor ? node.incrementor.end : pos, writePunctuation, node);
+        emitEmbeddedStatement(node, node.statement);
+    }
+    function emitForInStatement(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.ForKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, node);
+        emitForBinding(node.initializer);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.InKeyword, node.initializer.end, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.expression.end, writePunctuation, node);
+        emitEmbeddedStatement(node, node.statement);
+    }
+    function emitForOfStatement(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.ForKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitWithTrailingSpace(node.awaitModifier);
+        emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, node);
+        emitForBinding(node.initializer);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.OfKeyword, node.initializer.end, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.expression.end, writePunctuation, node);
+        emitEmbeddedStatement(node, node.statement);
+    }
+    function emitForBinding(node) {
+        if (node !== undefined) {
+            if (node.kind === SyntaxKind.VariableDeclarationList) {
+                emit(node);
+            }
+            else {
+                emitExpression(node);
+            }
+        }
+    }
+    function emitContinueStatement(node) {
+        emitTokenWithComment(SyntaxKind.ContinueKeyword, node.pos, writeKeyword, node);
+        writeTrailingSemicolon();
+    }
+    function emitBreakStatement(node) {
+        emitTokenWithComment(SyntaxKind.BreakKeyword, node.pos, writeKeyword, node);
+        writeTrailingSemicolon();
+    }
+    function emitTokenWithComment(token, pos, writer, contextNode, indentLeading) {
+        const node = getParseTreeNode(contextNode);
+        const isSimilarNode = node && node.kind === contextNode.kind;
+        const startPos = pos;
+        if (isSimilarNode && currentSourceFile) {
+            pos = skipTrivia(currentSourceFile.text, pos);
+        }
+        if (emitLeadingCommentsOfPosition && isSimilarNode && contextNode.pos !== startPos) {
+            const needsIndent = indentLeading && currentSourceFile && !positionsAreOnSameLine(startPos, pos, currentSourceFile);
+            if (needsIndent) {
+                increaseIndent();
+            }
+            emitLeadingCommentsOfPosition(startPos);
+            if (needsIndent) {
+                decreaseIndent();
+            }
+        }
+        pos = writeTokenText(token, writer, pos);
+        if (emitTrailingCommentsOfPosition && isSimilarNode && contextNode.end !== pos) {
+            emitTrailingCommentsOfPosition(pos, /*prefixSpace*/ true);
+        }
+        return pos;
+    }
+    function emitReturnStatement(node) {
+        emitTokenWithComment(SyntaxKind.ReturnKeyword, node.pos, writeKeyword, /*contextNode*/ node);
+        emitExpressionWithLeadingSpace(node.expression);
+        writeTrailingSemicolon();
+    }
+    function emitSwitchStatement(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.SwitchKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, node);
+        emitExpression(node.expression);
+        emitTokenWithComment(SyntaxKind.CloseParenToken, node.expression.end, writePunctuation, node);
+        writeSpace();
+        emit(node.caseBlock);
+    }
+    function emitThrowStatement(node) {
+        emitTokenWithComment(SyntaxKind.ThrowKeyword, node.pos, writeKeyword, node);
+        emitExpressionWithLeadingSpace(node.expression);
+        writeTrailingSemicolon();
+    }
+    function emitTryStatement(node) {
+        emitTokenWithComment(SyntaxKind.TryKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emit(node.tryBlock);
+        if (node.catchClause) {
+            writeLineOrSpace(node);
+            emit(node.catchClause);
+        }
+        if (node.finallyBlock) {
+            writeLineOrSpace(node);
+            emitTokenWithComment(SyntaxKind.FinallyKeyword, (node.catchClause || node.tryBlock).end, writeKeyword, node);
+            writeSpace();
+            emit(node.finallyBlock);
+        }
+    }
+    //
+    // Declarations
+    //
+    function emitVariableDeclaration(node) {
+        emit(node.name);
+        emit(node.exclamationToken);
+        emitTypeAnnotation(node.type);
+        emitInitializer(node.initializer, node.type ? node.type.end : node.name.end, node);
+    }
+    function emitVariableDeclarationList(node) {
+        writeKeyword(isLet(node) ? "let" : isVarConst(node) ? "const" : "var");
+        writeSpace();
+        emitList(node, node.declarations, 528 /* ListFormat.VariableDeclarationList */);
+    }
+    function emitBlockCallback(_hint, body) {
+        emitBlockFunctionBody(body);
+    }
+    function emitSignatureAndBody(node, emitSignatureHead) {
+        const body = node.body;
+        if (body) {
+            if (isBlock(body)) {
+                const indentedFlag = getEmitFlags(node) & EmitFlags.Indented;
+                if (indentedFlag) {
+                    increaseIndent();
+                }
+                pushNameGenerationScope(node);
+                forEach(node.parameters, generateNames);
+                generateNames(node.body);
+                emitSignatureHead(node);
+                if (onEmitNode) {
+                    onEmitNode(EmitHint.Unspecified, body, emitBlockCallback);
+                }
+                else {
+                    emitBlockFunctionBody(body);
+                }
+                popNameGenerationScope(node);
+                if (indentedFlag) {
+                    decreaseIndent();
+                }
+            }
+            else {
+                emitSignatureHead(node);
+                writeSpace();
+                emitExpression(body);
+            }
+        }
+        else {
+            emitSignatureHead(node);
+            writeTrailingSemicolon();
+        }
+    }
+    function shouldEmitBlockFunctionBodyOnSingleLine(body) {
+        // We must emit a function body as a single-line body in the following case:
+        // * The body has NodeEmitFlags.SingleLine specified.
+        // We must emit a function body as a multi-line body in the following cases:
+        // * The body is explicitly marked as multi-line.
+        // * A non-synthesized body's start and end position are on different lines.
+        // * Any statement in the body starts on a new line.
+        if (getEmitFlags(body) & EmitFlags.SingleLine) {
+            return true;
+        }
+        if (body.multiLine) {
+            return false;
+        }
+        if (!nodeIsSynthesized(body) && !rangeIsOnSingleLine(body, currentSourceFile)) {
+            return false;
+        }
+        if (getLeadingLineTerminatorCount(body, body.statements, 2 /* ListFormat.PreserveLines */)
+            || getClosingLineTerminatorCount(body, body.statements, 2 /* ListFormat.PreserveLines */)) {
+            return false;
+        }
+        let previousStatement;
+        for (const statement of body.statements) {
+            if (getSeparatingLineTerminatorCount(previousStatement, statement, 2 /* ListFormat.PreserveLines */) > 0) {
+                return false;
+            }
+            previousStatement = statement;
+        }
+        return true;
+    }
+    function emitBlockFunctionBody(body) {
+        writeSpace();
+        writePunctuation("{");
+        increaseIndent();
+        const emitBlockFunctionBody = shouldEmitBlockFunctionBodyOnSingleLine(body)
+            ? emitBlockFunctionBodyOnSingleLine
+            : emitBlockFunctionBodyWorker;
+        if (emitBodyWithDetachedComments) {
+            emitBodyWithDetachedComments(body, body.statements, emitBlockFunctionBody);
+        }
+        else {
+            emitBlockFunctionBody(body);
+        }
+        decreaseIndent();
+        writeToken(SyntaxKind.CloseBraceToken, body.statements.end, writePunctuation);
+    }
+    function emitBlockFunctionBodyOnSingleLine(body) {
+        emitBlockFunctionBodyWorker(body, /*emitBlockFunctionBodyOnSingleLine*/ true);
+    }
+    function emitBlockFunctionBodyWorker(body, emitBlockFunctionBodyOnSingleLine) {
+        // Emit all the prologue directives (like "use strict").
+        const statementOffset = emitPrologueDirectives(body.statements);
+        const pos = writer.getTextPos();
+        if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine) {
+            decreaseIndent();
+            emitList(body, body.statements, 768 /* ListFormat.SingleLineFunctionBodyStatements */);
+            increaseIndent();
+        }
+        else {
+            emitList(body, body.statements, 1 /* ListFormat.MultiLineFunctionBodyStatements */, statementOffset);
+        }
+    }
+    function emitTypeAliasDeclaration(node) {
+        emitModifiers(node, node.modifiers);
+        writeKeyword("type");
+        writeSpace();
+        emit(node.name);
+        emitTypeParameters(node, node.typeParameters);
+        writeSpace();
+        writePunctuation("=");
+        writeSpace();
+        emit(node.type);
+        writeTrailingSemicolon();
+    }
+    function emitModuleDeclaration(node) {
+        emitModifiers(node, node.modifiers);
+        if (~node.flags & NodeFlags.GlobalAugmentation) {
+            writeKeyword(node.flags & NodeFlags.Namespace ? "namespace" : "module");
+            writeSpace();
+        }
+        emit(node.name);
+        let body = node.body;
+        if (!body)
+            return writeTrailingSemicolon();
+        while (body.kind === SyntaxKind.ModuleDeclaration) {
+            writePunctuation(".");
+            emit(body.name);
+            body = body.body;
+        }
+        writeSpace();
+        emit(body);
+    }
+    function emitModuleBlock(node) {
+        pushNameGenerationScope(node);
+        forEach(node.statements, generateNames);
+        emitBlockStatements(node, /*forceSingleLine*/ isEmptyBlock(node));
+        popNameGenerationScope(node);
+    }
+    function emitCaseBlock(node) {
+        emitTokenWithComment(SyntaxKind.OpenBraceToken, node.pos, writePunctuation, node);
+        emitList(node, node.clauses, 129 /* ListFormat.CaseBlockClauses */);
+        emitTokenWithComment(SyntaxKind.CloseBraceToken, node.clauses.end, writePunctuation, node, /*indentLeading*/ true);
+    }
+    function emitImportDeclaration(node) {
+        emitModifiers(node, node.modifiers);
+        emitTokenWithComment(SyntaxKind.ImportKeyword, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
+        writeSpace();
+        if (node.importClause) {
+            emit(node.importClause);
+            writeSpace();
+            emitTokenWithComment(SyntaxKind.FromKeyword, node.importClause.end, writeKeyword, node);
+            writeSpace();
+        }
+        emitExpression(node.moduleSpecifier);
+        writeTrailingSemicolon();
+    }
+    function emitImportClause(node) {
+        if (node.isTypeOnly) {
+            emitTokenWithComment(SyntaxKind.TypeKeyword, node.pos, writeKeyword, node);
+            writeSpace();
+        }
+        emit(node.name);
+        if (node.name && node.namedBindings) {
+            emitTokenWithComment(SyntaxKind.CommaToken, node.name.end, writePunctuation, node);
+            writeSpace();
+        }
+        emit(node.namedBindings);
+    }
+    function emitNamespaceImport(node) {
+        const asPos = emitTokenWithComment(SyntaxKind.AsteriskToken, node.pos, writePunctuation, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.AsKeyword, asPos, writeKeyword, node);
+        writeSpace();
+        emit(node.name);
+    }
+    function emitNamedImports(node) {
+        emitNamedImportsOrExports(node);
+    }
+    function emitImportSpecifier(node) {
+        emitImportOrExportSpecifier(node);
+    }
+    function emitExportAssignment(node) {
+        const nextPos = emitTokenWithComment(SyntaxKind.ExportKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.DefaultKeyword, nextPos, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+        writeTrailingSemicolon();
+    }
+    function emitExportDeclaration(node) {
+        let nextPos = emitTokenWithComment(SyntaxKind.ExportKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        if (node.isTypeOnly) {
+            nextPos = emitTokenWithComment(SyntaxKind.TypeKeyword, nextPos, writeKeyword, node);
+            writeSpace();
+        }
+        if (node.exportClause) {
+            emit(node.exportClause);
+        }
+        else {
+            nextPos = emitTokenWithComment(SyntaxKind.AsteriskToken, nextPos, writePunctuation, node);
+        }
+        if (node.moduleSpecifier) {
+            writeSpace();
+            const fromPos = node.exportClause ? node.exportClause.end : nextPos;
+            emitTokenWithComment(SyntaxKind.FromKeyword, fromPos, writeKeyword, node);
+            writeSpace();
+            emitExpression(node.moduleSpecifier);
+        }
+        writeTrailingSemicolon();
+    }
+    function emitNamespaceExport(node) {
+        const asPos = emitTokenWithComment(SyntaxKind.AsteriskToken, node.pos, writePunctuation, node);
+        writeSpace();
+        emitTokenWithComment(SyntaxKind.AsKeyword, asPos, writeKeyword, node);
+        writeSpace();
+        emit(node.name);
+    }
+    function emitNamedExports(node) {
+        emitNamedImportsOrExports(node);
+    }
+    function emitExportSpecifier(node) {
+        emitImportOrExportSpecifier(node);
+    }
+    function emitNamedImportsOrExports(node) {
+        writePunctuation("{");
+        emitList(node, node.elements, 525136 /* ListFormat.NamedImportsOrExportsElements */);
+        writePunctuation("}");
+    }
+    function emitImportOrExportSpecifier(node) {
+        if (node.propertyName) {
+            emit(node.propertyName);
+            writeSpace();
+            emitTokenWithComment(SyntaxKind.AsKeyword, node.propertyName.end, writeKeyword, node);
+            writeSpace();
+        }
+        emit(node.name);
+    }
+    //
+    // JSX
+    //
+    function emitJsxElement(node) {
+        emit(node.openingElement);
+        emitList(node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
+        emit(node.closingElement);
+    }
+    function emitJsxSelfClosingElement(node) {
+        writePunctuation("<");
+        emitJsxTagName(node.tagName);
+        emitTypeArguments(node, node.typeArguments);
+        writeSpace();
+        emit(node.attributes);
+        writePunctuation("/>");
+    }
+    function emitJsxFragment(node) {
+        emit(node.openingFragment);
+        emitList(node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
+        emit(node.closingFragment);
+    }
+    function emitJsxOpeningElementOrFragment(node) {
+        writePunctuation("<");
+        if (isJsxOpeningElement(node)) {
+            const indented = writeLineSeparatorsAndIndentBefore(node.tagName, node);
+            emitJsxTagName(node.tagName);
+            emitTypeArguments(node, node.typeArguments);
+            if (node.attributes.properties && node.attributes.properties.length > 0) {
+                writeSpace();
+            }
+            emit(node.attributes);
+            writeLineSeparatorsAfter(node.attributes, node);
+            decreaseIndentIf(indented);
+        }
+        writePunctuation(">");
+    }
+    function emitJsxText(node) {
+        writer.writeLiteral(node.text);
+    }
+    function emitJsxClosingElementOrFragment(node) {
+        writePunctuation("</");
+        if (isJsxClosingElement(node)) {
+            emitJsxTagName(node.tagName);
+        }
+        writePunctuation(">");
+    }
+    function emitJsxAttributes(node) {
+        emitList(node, node.properties, 262656 /* ListFormat.JsxElementAttributes */);
+    }
+    function emitJsxAttribute(node) {
+        emit(node.name);
+        emitNodeWithPrefix("=", writePunctuation, node.initializer, emitJsxAttributeValue);
+    }
+    function emitJsxSpreadAttribute(node) {
+        writePunctuation("{...");
+        emitExpression(node.expression);
+        writePunctuation("}");
+    }
+    function emitJsxExpression(node) {
+        if (node.expression) {
+            writePunctuation("{");
+            emit(node.dotDotDotToken);
+            emitExpression(node.expression);
+            writePunctuation("}");
+        }
+    }
+    function emitJsxTagName(node) {
+        if (node.kind === SyntaxKind.Identifier) {
+            emitExpression(node);
+        }
+        else {
+            emit(node);
+        }
+    }
+    //
+    // Clauses
+    //
+    function emitCaseClause(node) {
+        emitTokenWithComment(SyntaxKind.CaseKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        emitExpression(node.expression);
+        emitCaseOrDefaultClauseRest(node, node.statements, node.expression.end);
+    }
+    function emitDefaultClause(node) {
+        const pos = emitTokenWithComment(SyntaxKind.DefaultKeyword, node.pos, writeKeyword, node);
+        emitCaseOrDefaultClauseRest(node, node.statements, pos);
+    }
+    function emitCaseOrDefaultClauseRest(parentNode, statements, colonPos) {
+        const emitAsSingleStatement = statements.length === 1 &&
+            (
+            // treat synthesized nodes as located on the same line for emit purposes
+            nodeIsSynthesized(parentNode) ||
+                nodeIsSynthesized(statements[0]) ||
+                rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile));
+        let format = 163969 /* ListFormat.CaseOrDefaultClauseStatements */;
+        if (emitAsSingleStatement) {
+            writeToken(SyntaxKind.ColonToken, colonPos, writePunctuation);
+            writeSpace();
+            format &= ~(1 /* ListFormat.MultiLine */ | 128 /* ListFormat.Indented */);
+        }
+        else {
+            emitTokenWithComment(SyntaxKind.ColonToken, colonPos, writePunctuation, parentNode);
+        }
+        emitList(parentNode, statements, format);
+    }
+    function emitCatchClause(node) {
+        const openParenPos = emitTokenWithComment(SyntaxKind.CatchKeyword, node.pos, writeKeyword, node);
+        writeSpace();
+        if (node.variableDeclaration) {
+            emitTokenWithComment(SyntaxKind.OpenParenToken, openParenPos, writePunctuation, node);
+            emit(node.variableDeclaration);
+            emitTokenWithComment(SyntaxKind.CloseParenToken, node.variableDeclaration.end, writePunctuation, node);
+            writeSpace();
+        }
+        emit(node.block);
+    }
+    //
+    // Property assignments
+    //
+    function emitPropertyAssignment(node) {
+        emit(node.name);
+        writePunctuation(":");
+        writeSpace();
+        // This is to ensure that we emit comment in the following case:
+        //      For example:
+        //          obj = {
+        //              id: /*comment1*/ ()=>void
+        //          }
+        // "comment1" is not considered to be leading comment for node.initializer
+        // but rather a trailing comment on the previous node.
+        const initializer = node.initializer;
+        if (emitTrailingCommentsOfPosition && (getEmitFlags(initializer) & EmitFlags.NoLeadingComments) === 0) {
+            const commentRange = getCommentRange(initializer);
+            emitTrailingCommentsOfPosition(commentRange.pos);
+        }
+        emitExpression(initializer);
+    }
+    function emitShorthandPropertyAssignment(node) {
+        emit(node.name);
+        if (node.objectAssignmentInitializer) {
+            writeSpace();
+            writePunctuation("=");
+            writeSpace();
+            emitExpression(node.objectAssignmentInitializer);
+        }
+    }
+    function emitSpreadAssignment(node) {
+        if (node.expression) {
+            emitTokenWithComment(SyntaxKind.DotDotDotToken, node.pos, writePunctuation, node);
+            emitExpression(node.expression);
+        }
+    }
+    //
+    // Top-level nodes
+    //
+    function emitSourceFile(node) {
+        writeLine();
+        const statements = node.statements;
+        if (emitBodyWithDetachedComments) {
+            // Emit detached comment if there are no prologue directives or if the first node is synthesized.
+            // The synthesized node will have no leading comment so some comments may be missed.
+            const shouldEmitDetachedComment = statements.length === 0 ||
+                !isPrologueDirective(statements[0]) ||
+                nodeIsSynthesized(statements[0]);
+            if (shouldEmitDetachedComment) {
+                emitBodyWithDetachedComments(node, statements, emitSourceFileWorker);
+                return;
+            }
+        }
+        emitSourceFileWorker(node);
+    }
+    function emitSourceFileWorker(node) {
+        const statements = node.statements;
+        pushNameGenerationScope(node);
+        forEach(node.statements, generateNames);
+        const index = findIndex(statements, statement => !isPrologueDirective(statement));
+        emitList(node, statements, 1 /* ListFormat.MultiLine */, index === -1 ? statements.length : index);
+        popNameGenerationScope(node);
+    }
+    /**
+     * Emits any prologue directives at the start of a Statement list, returning the
+     * number of prologue directives written to the output.
+     */
+    function emitPrologueDirectives(statements, sourceFile) {
+        let needsToSetSourceFile = !!sourceFile;
+        for (let i = 0; i < statements.length; i++) {
+            const statement = statements[i];
+            if (isPrologueDirective(statement)) {
+                if (needsToSetSourceFile) {
+                    needsToSetSourceFile = false;
+                    setSourceFile(sourceFile);
+                }
+                writeLine();
+                emit(statement);
+            }
+            else {
+                // return index of the first non prologue directive
+                return i;
+            }
+        }
+        return statements.length;
+    }
+    function emitPrologueDirectivesIfNeeded(sourceFile) {
+        emitPrologueDirectives(sourceFile.statements, sourceFile);
+    }
+    function emitShebangIfNeeded(sourceFile) {
+        const shebang = getShebang(sourceFile.text);
+        if (shebang) {
+            writeComment(shebang);
+            writeLine();
+            return true;
+        }
+    }
+    //
+    // Helpers
+    //
+    function emitNodeWithWriter(node, writer) {
+        if (!node)
+            return;
+        const savedWrite = write;
+        write = writer;
+        emit(node);
+        write = savedWrite;
+    }
+    function emitModifiers(node, modifiers) {
+        if (modifiers && modifiers.length) {
+            emitList(node, modifiers, 262656 /* ListFormat.Modifiers */);
+            writeSpace();
+        }
+    }
+    function emitTypeAnnotation(node) {
+        if (node) {
+            writePunctuation(":");
+            writeSpace();
+            emit(node);
+        }
+    }
+    function emitInitializer(node, equalCommentStartPos, container) {
+        if (node) {
+            writeSpace();
+            emitTokenWithComment(SyntaxKind.EqualsToken, equalCommentStartPos, writeOperator, container);
+            writeSpace();
+            emitExpression(node);
+        }
+    }
+    function emitNodeWithPrefix(prefix, prefixWriter, node, emit) {
+        if (node) {
+            prefixWriter(prefix);
+            emit(node);
+        }
+    }
+    function emitExpressionWithLeadingSpace(node) {
+        if (node) {
+            writeSpace();
+            emitExpression(node);
+        }
+    }
+    function emitWithTrailingSpace(node) {
+        if (node) {
+            emit(node);
+            writeSpace();
+        }
+    }
+    function emitEmbeddedStatement(parent, node) {
+        if (isBlock(node) || getEmitFlags(parent) & EmitFlags.SingleLine) {
+            writeSpace();
+            emit(node);
+        }
+        else {
+            writeLine();
+            increaseIndent();
+            if (isEmptyStatement(node)) {
+                pipelineEmit(EmitHint.EmbeddedStatement, node);
+            }
+            else {
+                emit(node);
+            }
+            decreaseIndent();
+        }
+    }
+    function emitTypeArguments(parentNode, typeArguments) {
+        emitList(parentNode, typeArguments, 53776 /* ListFormat.TypeArguments */);
+    }
+    function emitTypeParameters(parentNode, typeParameters) {
+        if (isFunctionLike(parentNode) && parentNode.typeArguments) { // Quick info uses type arguments in place of type parameters on instantiated signatures
+            return emitTypeArguments(parentNode, parentNode.typeArguments);
+        }
+        emitList(parentNode, typeParameters, 53776 /* ListFormat.TypeParameters */);
+    }
+    function emitParameters(parentNode, parameters) {
+        emitList(parentNode, parameters, 2576 /* ListFormat.Parameters */);
+    }
+    function canEmitSimpleArrowHead(parentNode, parameters) {
+        const parameter = singleOrUndefined(parameters);
+        return parameter
+            && parameter.pos === parentNode.pos // may not have parsed tokens between parent and parameter
+            && isArrowFunction(parentNode) // only arrow functions may have simple arrow head
+            && !parentNode.type // arrow function may not have return type annotation
+            && !some(parentNode.modifiers) // parent may not have modifiers
+            && !some(parentNode.typeParameters) // parent may not have type parameters
+            && !some(parameter.modifiers) // parameter may not have modifiers
+            && !parameter.dotDotDotToken // parameter may not be rest
+            && !parameter.questionToken // parameter may not be optional
+            && !parameter.type // parameter may not have a type annotation
+            && !parameter.initializer // parameter may not have an initializer
+            && isIdentifier(parameter.name); // parameter name must be identifier
+    }
+    function emitParametersForArrow(parentNode, parameters) {
+        if (canEmitSimpleArrowHead(parentNode, parameters)) {
+            emitList(parentNode, parameters, 2576 /* ListFormat.Parameters */ & ~2048 /* ListFormat.Parenthesis */);
+        }
+        else {
+            emitParameters(parentNode, parameters);
+        }
+    }
+    function emitParametersForIndexSignature(parentNode, parameters) {
+        emitList(parentNode, parameters, 8848 /* ListFormat.IndexSignatureParameters */);
+    }
+    function emitList(parentNode, children, format, start, count) {
+        emitNodeList(emit, parentNode, children, format, start, count);
+    }
+    function emitExpressionList(parentNode, children, format, start, count) {
+        emitNodeList(emitExpression, parentNode, children, format, start, count);
+    }
+    function writeDelimiter(format) {
+        switch (format & 28 /* ListFormat.DelimitersMask */) {
+            case 0 /* ListFormat.None */:
+                break;
+            case 16 /* ListFormat.CommaDelimited */:
+                writePunctuation(",");
+                break;
+            case 4 /* ListFormat.BarDelimited */:
+                writeSpace();
+                writePunctuation("|");
+                break;
+            case 8 /* ListFormat.AmpersandDelimited */:
+                writeSpace();
+                writePunctuation("&");
+                break;
+        }
+    }
+    function emitNodeList(emit, parentNode, children, format, start = 0, count = children ? children.length - start : 0) {
+        const isUndefined = children === undefined;
+        if (isUndefined && format & 16384 /* ListFormat.OptionalIfUndefined */) {
+            return;
+        }
+        const isEmpty = children === undefined || start >= children.length || count === 0;
+        if (isEmpty && format & 32768 /* ListFormat.OptionalIfEmpty */) {
+            if (onBeforeEmitNodeArray) {
+                onBeforeEmitNodeArray(children);
+            }
+            if (onAfterEmitNodeArray) {
+                onAfterEmitNodeArray(children);
+            }
+            return;
+        }
+        if (format & 15360 /* ListFormat.BracketsMask */) {
+            writePunctuation(getOpeningBracket(format));
+            if (isEmpty && !isUndefined) {
+                emitTrailingCommentsOfPosition(children.pos, /*prefixSpace*/ true); // Emit comments within empty bracketed lists
+            }
+        }
+        if (onBeforeEmitNodeArray) {
+            onBeforeEmitNodeArray(children);
+        }
+        if (isEmpty) {
+            // Write a line terminator if the parent node was multi-line
+            if (format & 1 /* ListFormat.MultiLine */ && !(preserveSourceNewlines && rangeIsOnSingleLine(parentNode, currentSourceFile))) {
+                writeLine();
+            }
+            else if (format & 256 /* ListFormat.SpaceBetweenBraces */ && !(format & 524288 /* ListFormat.NoSpaceIfEmpty */)) {
+                writeSpace();
+            }
+        }
+        else {
+            // Write the opening line terminator or leading whitespace.
+            const mayEmitInterveningComments = (format & 262144 /* ListFormat.NoInterveningComments */) === 0;
+            let shouldEmitInterveningComments = mayEmitInterveningComments;
+            const leadingLineTerminatorCount = getLeadingLineTerminatorCount(parentNode, children, format);
+            if (leadingLineTerminatorCount) {
+                writeLine(leadingLineTerminatorCount);
+                shouldEmitInterveningComments = false;
+            }
+            else if (format & 256 /* ListFormat.SpaceBetweenBraces */) {
+                writeSpace();
+            }
+            // Increase the indent, if requested.
+            if (format & 128 /* ListFormat.Indented */) {
+                increaseIndent();
+            }
+            // Emit each child.
+            let previousSibling;
+            let shouldDecreaseIndentAfterEmit = false;
+            for (let i = 0; i < count; i++) {
+                const child = children[start + i];
+                // Write the delimiter if this is not the first node.
+                if (previousSibling) {
+                    // i.e
+                    //      function commentedParameters(
+                    //          /* Parameter a */
+                    //          a
+                    //          /* End of parameter a */ -> this comment isn't considered to be trailing comment of parameter "a" due to newline
+                    //          ,
+                    if (format & 28 /* ListFormat.DelimitersMask */ && previousSibling.end !== parentNode.end) {
+                        emitLeadingCommentsOfPosition(previousSibling.end);
+                    }
+                    writeDelimiter(format);
+                    // Write either a line terminator or whitespace to separate the elements.
+                    const separatingLineTerminatorCount = getSeparatingLineTerminatorCount(previousSibling, child, format);
+                    if (separatingLineTerminatorCount > 0) {
+                        // If a synthesized node in a single-line list starts on a new
+                        // line, we should increase the indent.
+                        if ((format & (3 /* ListFormat.LinesMask */ | 128 /* ListFormat.Indented */)) === 0 /* ListFormat.SingleLine */) {
+                            increaseIndent();
+                            shouldDecreaseIndentAfterEmit = true;
+                        }
+                        writeLine(separatingLineTerminatorCount);
+                        shouldEmitInterveningComments = false;
+                    }
+                    else if (previousSibling && format & 512 /* ListFormat.SpaceBetweenSiblings */) {
+                        writeSpace();
+                    }
+                }
+                // Emit this child.
+                if (shouldEmitInterveningComments) {
+                    if (emitTrailingCommentsOfPosition) {
+                        const commentRange = getCommentRange(child);
+                        emitTrailingCommentsOfPosition(commentRange.pos);
+                    }
+                }
+                else {
+                    shouldEmitInterveningComments = mayEmitInterveningComments;
+                }
+                emit(child);
+                if (shouldDecreaseIndentAfterEmit) {
+                    decreaseIndent();
+                    shouldDecreaseIndentAfterEmit = false;
+                }
+                previousSibling = child;
+            }
+            // Write a trailing comma, if requested.
+            const hasTrailingComma = (format & 64 /* ListFormat.AllowTrailingComma */) && children.hasTrailingComma;
+            if (format & 16 /* ListFormat.CommaDelimited */ && hasTrailingComma) {
+                writePunctuation(",");
+            }
+            // Emit any trailing comment of the last element in the list
+            // i.e
+            //       var array = [...
+            //          2
+            //          /* end of element 2 */
+            //       ];
+            if (previousSibling && format & 28 /* ListFormat.DelimitersMask */ && previousSibling.end !== parentNode.end && !(getEmitFlags(previousSibling) & EmitFlags.NoTrailingComments)) {
+                emitLeadingCommentsOfPosition(previousSibling.end);
+            }
+            // Decrease the indent, if requested.
+            if (format & 128 /* ListFormat.Indented */) {
+                decreaseIndent();
+            }
+            // Write the closing line terminator or closing whitespace.
+            const closingLineTerminatorCount = getClosingLineTerminatorCount(parentNode, children, format);
+            if (closingLineTerminatorCount) {
+                writeLine(closingLineTerminatorCount);
+            }
+            else if (format & (2097152 /* ListFormat.SpaceAfterList */ | 256 /* ListFormat.SpaceBetweenBraces */)) {
+                writeSpace();
+            }
+        }
+        if (onAfterEmitNodeArray) {
+            onAfterEmitNodeArray(children);
+        }
+        if (format & 15360 /* ListFormat.BracketsMask */) {
+            if (isEmpty && !isUndefined) {
+                emitLeadingCommentsOfPosition(children.end); // Emit leading comments within empty lists
+            }
+            writePunctuation(getClosingBracket(format));
+        }
+    }
+    // Writers
+    function writeLiteral(s) {
+        writer.writeLiteral(s);
+    }
+    function writeStringLiteral(s) {
+        writer.writeStringLiteral(s);
+    }
+    function writeBase(s) {
+        writer.write(s);
+    }
+    function writeSymbol(s, sym) {
+        writer.writeSymbol(s, sym);
+    }
+    function writePunctuation(s) {
+        writer.writePunctuation(s);
+    }
+    function writeTrailingSemicolon() {
+        writer.writeTrailingSemicolon(";");
+    }
+    function writeKeyword(s) {
+        writer.writeKeyword(s);
+    }
+    function writeOperator(s) {
+        writer.writeOperator(s);
+    }
+    function writeParameter(s) {
+        writer.writeParameter(s);
+    }
+    function writeComment(s) {
+        writer.writeComment(s);
+    }
+    function writeSpace() {
+        writer.writeSpace(" ");
+    }
+    function writeProperty(s) {
+        writer.writeProperty(s);
+    }
+    function writeLine(count = 1) {
+        for (let i = 0; i < count; i++) {
+            writer.writeLine(i > 0);
+        }
+    }
+    function increaseIndent() {
+        writer.increaseIndent();
+    }
+    function decreaseIndent() {
+        writer.decreaseIndent();
+    }
+    function writeToken(token, pos, writer) {
+        return writeTokenText(token, writer, pos);
+    }
+    function writeTokenNode(node, writer) {
+        if (onBeforeEmitToken) {
+            onBeforeEmitToken(node);
+        }
+        writer(tokenToString(node.kind));
+        if (onAfterEmitToken) {
+            onAfterEmitToken(node);
+        }
+    }
+    function writeTokenText(token, writer, pos) {
+        const tokenString = tokenToString(token);
+        writer(tokenString);
+        return pos < 0 ? pos : pos + tokenString.length;
+    }
+    function writeLineOrSpace(node) {
+        if (getEmitFlags(node) & EmitFlags.SingleLine) {
+            writeSpace();
+        }
+        else {
+            writeLine();
+        }
+    }
+    function writeLinesAndIndent(lineCount, writeSpaceIfNotIndenting) {
+        if (lineCount) {
+            increaseIndent();
+            writeLine(lineCount);
+        }
+        else if (writeSpaceIfNotIndenting) {
+            writeSpace();
+        }
+    }
+    // Helper function to decrease the indent if we previously indented.  Allows multiple
+    // previous indent values to be considered at a time.  This also allows caller to just
+    // call this once, passing in all their appropriate indent values, instead of needing
+    // to call this helper function multiple times.
+    function decreaseIndentIf(value1, value2) {
+        if (value1) {
+            decreaseIndent();
+        }
+        if (value2) {
+            decreaseIndent();
+        }
+    }
+    function getLeadingLineTerminatorCount(parentNode, children, format) {
+        if (format & 2 /* ListFormat.PreserveLines */ || preserveSourceNewlines) {
+            if (format & 65536 /* ListFormat.PreferNewLine */) {
+                return 1;
+            }
+            const firstChild = children[0];
+            if (firstChild === undefined) {
+                return rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
+            }
+            if (firstChild.kind === SyntaxKind.JsxText) {
+                // JsxText will be written with its leading whitespace, so don't add more manually.
+                return 0;
+            }
+            if (!positionIsSynthesized(parentNode.pos) && !nodeIsSynthesized(firstChild) && (!firstChild.parent || firstChild.parent === parentNode)) {
+                if (preserveSourceNewlines) {
+                    return getEffectiveLines(includeComments => getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(firstChild.pos, parentNode.pos, currentSourceFile, includeComments));
+                }
+                return rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile) ? 0 : 1;
+            }
+            if (synthesizedNodeStartsOnNewLine(firstChild, format)) {
+                return 1;
+            }
+        }
+        return format & 1 /* ListFormat.MultiLine */ ? 1 : 0;
+    }
+    function getSeparatingLineTerminatorCount(previousNode, nextNode, format) {
+        if (format & 2 /* ListFormat.PreserveLines */ || preserveSourceNewlines) {
+            if (previousNode === undefined || nextNode === undefined) {
+                return 0;
+            }
+            if (nextNode.kind === SyntaxKind.JsxText) {
+                // JsxText will be written with its leading whitespace, so don't add more manually.
+                return 0;
+            }
+            else if (!nodeIsSynthesized(previousNode) && !nodeIsSynthesized(nextNode) && previousNode.parent === nextNode.parent) {
+                if (preserveSourceNewlines) {
+                    return getEffectiveLines(includeComments => getLinesBetweenRangeEndAndRangeStart(previousNode, nextNode, currentSourceFile, includeComments));
+                }
+                return rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile) ? 0 : 1;
+            }
+            else if (synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format)) {
+                return 1;
+            }
+        }
+        else if (getStartsOnNewLine(nextNode)) {
+            return 1;
+        }
+        return format & 1 /* ListFormat.MultiLine */ ? 1 : 0;
+    }
+    function getClosingLineTerminatorCount(parentNode, children, format) {
+        if (format & 2 /* ListFormat.PreserveLines */ || preserveSourceNewlines) {
+            if (format & 65536 /* ListFormat.PreferNewLine */) {
+                return 1;
+            }
+            const lastChild = lastOrUndefined(children);
+            if (lastChild === undefined) {
+                return rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
+            }
+            if (!positionIsSynthesized(parentNode.pos) && !nodeIsSynthesized(lastChild) && (!lastChild.parent || lastChild.parent === parentNode)) {
+                if (preserveSourceNewlines) {
+                    return getEffectiveLines(includeComments => getLinesBetweenPositionAndNextNonWhitespaceCharacter(lastChild.end, parentNode.end, currentSourceFile, includeComments));
+                }
+                return rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile) ? 0 : 1;
+            }
+            if (synthesizedNodeStartsOnNewLine(lastChild, format)) {
+                return 1;
+            }
+        }
+        if (format & 1 /* ListFormat.MultiLine */ && !(format & 131072 /* ListFormat.NoTrailingNewLine */)) {
+            return 1;
+        }
+        return 0;
+    }
+    function getEffectiveLines(getLineDifference) {
+        // If 'preserveSourceNewlines' is disabled, we should never call this function
+        // because it could be more expensive than alternative approximations.
+        Debug.assert(!!preserveSourceNewlines);
+        // We start by measuring the line difference from a position to its adjacent comments,
+        // so that this is counted as a one-line difference, not two:
+        //
+        //   node1;
+        //   // NODE2 COMMENT
+        //   node2;
+        const lines = getLineDifference(/*includeComments*/ true);
+        if (lines === 0) {
+            // However, if the line difference considering comments was 0, we might have this:
+            //
+            //   node1; // NODE2 COMMENT
+            //   node2;
+            //
+            // in which case we should be ignoring node2's comment, so this too is counted as
+            // a one-line difference, not zero.
+            return getLineDifference(/*includeComments*/ false);
+        }
+        return lines;
+    }
+    function writeLineSeparatorsAndIndentBefore(node, parent) {
+        const leadingNewlines = preserveSourceNewlines && getLeadingLineTerminatorCount(parent, [node], 0 /* ListFormat.None */);
+        if (leadingNewlines) {
+            writeLinesAndIndent(leadingNewlines, /*writeLinesIfNotIndenting*/ false);
+        }
+        return !!leadingNewlines;
+    }
+    function writeLineSeparatorsAfter(node, parent) {
+        const trailingNewlines = preserveSourceNewlines && getClosingLineTerminatorCount(parent, [node], 0 /* ListFormat.None */);
+        if (trailingNewlines) {
+            writeLine(trailingNewlines);
+        }
+    }
+    function synthesizedNodeStartsOnNewLine(node, format) {
+        if (nodeIsSynthesized(node)) {
+            const startsOnNewLine = getStartsOnNewLine(node);
+            if (startsOnNewLine === undefined) {
+                return (format & 65536 /* ListFormat.PreferNewLine */) !== 0;
+            }
+            return startsOnNewLine;
+        }
+        return (format & 65536 /* ListFormat.PreferNewLine */) !== 0;
+    }
+    function getLinesBetweenNodes(parent, node1, node2) {
+        if (getEmitFlags(parent) & EmitFlags.NoIndentation) {
+            return 0;
+        }
+        parent = skipSynthesizedParentheses(parent);
+        node1 = skipSynthesizedParentheses(node1);
+        node2 = skipSynthesizedParentheses(node2);
+        // Always use a newline for synthesized code if the synthesizer desires it.
+        if (getStartsOnNewLine(node2)) {
+            return 1;
+        }
+        if (!nodeIsSynthesized(parent) && !nodeIsSynthesized(node1) && !nodeIsSynthesized(node2)) {
+            if (preserveSourceNewlines) {
+                return getEffectiveLines(includeComments => getLinesBetweenRangeEndAndRangeStart(node1, node2, currentSourceFile, includeComments));
+            }
+            return rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile) ? 0 : 1;
+        }
+        return 0;
+    }
+    function isEmptyBlock(block) {
+        return block.statements.length === 0
+            && rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile);
+    }
+    function skipSynthesizedParentheses(node) {
+        while (node.kind === SyntaxKind.ParenthesizedExpression && nodeIsSynthesized(node)) {
+            node = node.expression;
+        }
+        return node;
+    }
+    function getTextOfNode(node, includeTrivia) {
+        if (isGeneratedIdentifier(node)) {
+            return generateName(node);
+        }
+        else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent || !currentSourceFile || (node.parent && currentSourceFile && getSourceFileOfNode(node) !== getOriginalNode(currentSourceFile)))) {
+            return idText(node);
+        }
+        else if (node.kind === SyntaxKind.StringLiteral && node.textSourceNode) {
+            return getTextOfNode(node.textSourceNode, includeTrivia);
+        }
+        else if (isLiteralExpression(node) && (nodeIsSynthesized(node) || !node.parent)) {
+            return node.text;
+        }
+        return getSourceTextOfNodeFromSourceFile(currentSourceFile, node, includeTrivia);
+    }
+    function getLiteralTextOfNode(node, neverAsciiEscape, jsxAttributeEscape) {
+        if (node.kind === SyntaxKind.StringLiteral && node.textSourceNode) {
+            const textSourceNode = node.textSourceNode;
+            if (isIdentifier(textSourceNode)) {
+                return jsxAttributeEscape ? `"${escapeJsxAttributeString(getTextOfNode(textSourceNode))}"` :
+                    neverAsciiEscape || (getEmitFlags(node) & EmitFlags.NoAsciiEscaping) ? `"${escapeString(getTextOfNode(textSourceNode))}"` :
+                        `"${escapeNonAsciiString(getTextOfNode(textSourceNode))}"`;
+            }
+            else {
+                return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape);
+            }
+        }
+        return getLiteralText(node, currentSourceFile, neverAsciiEscape, jsxAttributeEscape);
+    }
+    /**
+     * Push a new name generation scope.
+     */
+    function pushNameGenerationScope(node) {
+        if (node && getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) {
+            return;
+        }
+        tempFlagsStack.push(tempFlags);
+        tempFlags = 0;
+        reservedNamesStack.push(reservedNames);
+    }
+    /**
+     * Pop the current name generation scope.
+     */
+    function popNameGenerationScope(node) {
+        if (node && getEmitFlags(node) & EmitFlags.ReuseTempVariableScope) {
+            return;
+        }
+        tempFlags = tempFlagsStack.pop();
+        reservedNames = reservedNamesStack.pop();
+    }
+    function reserveNameInNestedScopes(name) {
+        if (!reservedNames || reservedNames === lastOrUndefined(reservedNamesStack)) {
+            reservedNames = createMap();
+        }
+        reservedNames.set(name, true);
+    }
+    function generateNames(node) {
+        if (!node)
+            return;
+        switch (node.kind) {
+            case SyntaxKind.Block:
+                forEach(node.statements, generateNames);
+                break;
+            case SyntaxKind.DoStatement:
+            case SyntaxKind.WhileStatement:
+                generateNames(node.statement);
+                break;
+            case SyntaxKind.IfStatement:
+                generateNames(node.thenStatement);
+                generateNames(node.elseStatement);
+                break;
+            case SyntaxKind.ForStatement:
+            case SyntaxKind.ForOfStatement:
+            case SyntaxKind.ForInStatement:
+                generateNames(node.initializer);
+                generateNames(node.statement);
+                break;
+            case SyntaxKind.SwitchStatement:
+                generateNames(node.caseBlock);
+                break;
+            case SyntaxKind.CaseBlock:
+                forEach(node.clauses, generateNames);
+                break;
+            case SyntaxKind.CaseClause:
+            case SyntaxKind.DefaultClause:
+                forEach(node.statements, generateNames);
+                break;
+            case SyntaxKind.TryStatement:
+                generateNames(node.tryBlock);
+                generateNames(node.catchClause);
+                generateNames(node.finallyBlock);
+                break;
+            case SyntaxKind.CatchClause:
+                generateNames(node.variableDeclaration);
+                generateNames(node.block);
+                break;
+            case SyntaxKind.VariableStatement:
+                generateNames(node.declarationList);
+                break;
+            case SyntaxKind.VariableDeclarationList:
+                forEach(node.declarations, generateNames);
+                break;
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.Parameter:
+            case SyntaxKind.BindingElement:
+                generateNameIfNeeded(node.name);
+                break;
+            case SyntaxKind.ObjectBindingPattern:
+            case SyntaxKind.ArrayBindingPattern:
+                forEach(node.elements, generateNames);
+                break;
+            case SyntaxKind.ImportDeclaration:
+                generateNames(node.importClause);
+                break;
+            case SyntaxKind.ImportClause:
+                generateNameIfNeeded(node.name);
+                generateNames(node.namedBindings);
+                break;
+            case SyntaxKind.NamespaceImport:
+                generateNameIfNeeded(node.name);
+                break;
+            case SyntaxKind.NamespaceExport:
+                generateNameIfNeeded(node.name);
+                break;
+            case SyntaxKind.NamedImports:
+                forEach(node.elements, generateNames);
+                break;
+            case SyntaxKind.ImportSpecifier:
+                generateNameIfNeeded(node.propertyName || node.name);
+                break;
+        }
+    }
+    function generateMemberNames(node) {
+        if (!node)
+            return;
+        switch (node.kind) {
+            case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
+                generateNameIfNeeded(node.name);
+                break;
+        }
+    }
+    function generateNameIfNeeded(name) {
+        if (name) {
+            if (isGeneratedIdentifier(name)) {
+                generateName(name);
+            }
+            else if (isBindingPattern(name)) {
+                generateNames(name);
+            }
+        }
+    }
+    /**
+     * Generate the text for a generated identifier.
+     */
+    function generateName(name) {
+        if ((name.autoGenerateFlags & GeneratedIdentifierFlags.KindMask) === GeneratedIdentifierFlags.Node) {
+            // Node names generate unique names based on their original node
+            // and are cached based on that node's id.
+            return generateNameCached(getNodeForGeneratedName(name), name.autoGenerateFlags);
+        }
+        else {
+            // Auto, Loop, and Unique names are cached based on their unique
+            // autoGenerateId.
+            const autoGenerateId = name.autoGenerateId;
+            return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = makeName(name));
+        }
+    }
+    function generateNameCached(node, flags) {
+        const nodeId = getNodeId(node);
+        return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, flags));
+    }
+    /**
+     * Returns a value indicating whether a name is unique globally, within the current file,
+     * or within the NameGenerator.
+     */
+    function isUniqueName(name) {
+        return isFileLevelUniqueName(name)
+            && !generatedNames.has(name)
+            && !(reservedNames && reservedNames.has(name));
+    }
+    /**
+     * Returns a value indicating whether a name is unique globally or within the current file.
+     */
+    function isFileLevelUniqueName(name) {
+        return currentSourceFile ? ts.isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
+    }
+    /**
+     * Returns a value indicating whether a name is unique within a container.
+     */
+    function isUniqueLocalName(name, container) {
+        for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
+            if (node.locals) {
+                const local = node.locals.get(escapeLeadingUnderscores(name));
+                // We conservatively include alias symbols to cover cases where they're emitted as locals
+                if (local && local.flags & (SymbolFlags.Value | SymbolFlags.ExportValue | SymbolFlags.Alias)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * 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, reservedInNestedScopes) {
+        if (flags && !(tempFlags & flags)) {
+            const name = flags === 268435456 /* TempFlags._i */ ? "_i" : "_n";
+            if (isUniqueName(name)) {
+                tempFlags |= flags;
+                if (reservedInNestedScopes) {
+                    reserveNameInNestedScopes(name);
+                }
+                return name;
+            }
+        }
+        while (true) {
+            const count = tempFlags & 268435455 /* TempFlags.CountMask */;
+            tempFlags++;
+            // Skip over 'i' and 'n'
+            if (count !== 8 && count !== 13) {
+                const name = count < 26
+                    ? "_" + String.fromCharCode(CharacterCodes.a + count)
+                    : "_" + (count - 26);
+                if (isUniqueName(name)) {
+                    if (reservedInNestedScopes) {
+                        reserveNameInNestedScopes(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.
+     * If `optimistic` is set, the first instance will use 'baseName' verbatim instead of 'baseName_1'
+     */
+    function makeUniqueName(baseName, checkFn = isUniqueName, optimistic, scoped) {
+        if (optimistic) {
+            if (checkFn(baseName)) {
+                if (scoped) {
+                    reserveNameInNestedScopes(baseName);
+                }
+                else {
+                    generatedNames.set(baseName, true);
+                }
+                return baseName;
+            }
+        }
+        // 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) {
+            const generatedName = baseName + i;
+            if (checkFn(generatedName)) {
+                if (scoped) {
+                    reserveNameInNestedScopes(generatedName);
+                }
+                else {
+                    generatedNames.set(generatedName, true);
+                }
+                return generatedName;
+            }
+            i++;
+        }
+    }
+    /** O nome único de uma `ModuleDeclaration`: o próprio nome, se é único, ou uma variação dele. */
+    function generateNameForModuleOrEnum(node) {
+        const name = getTextOfNode(node.name);
+        return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
+    }
+    /**
+     * Generates a unique name for an ImportDeclaration or ExportDeclaration.
+     */
+    function generateNameForImportOrExportDeclaration(node) {
+        const expr = getExternalModuleName(node);
+        const baseName = isStringLiteral(expr) ?
+            makeIdentifierFromModuleName(expr.text) : "module";
+        return makeUniqueName(baseName);
+    }
+    /**
+     * Generates a unique name for a default export.
+     */
+    function generateNameForExportDefault() {
+        return makeUniqueName("default");
+    }
+    /**
+     * Generates a unique name from a node.
+     */
+    function generateNameForNode(node, flags) {
+        switch (node.kind) {
+            case SyntaxKind.Identifier:
+                return makeUniqueName(getTextOfNode(node), isUniqueName, !!(flags & GeneratedIdentifierFlags.Optimistic), !!(flags & GeneratedIdentifierFlags.ReservedInNestedScopes));
+            case SyntaxKind.ModuleDeclaration:
+                return generateNameForModuleOrEnum(node);
+            case SyntaxKind.ImportDeclaration:
+            case SyntaxKind.ExportDeclaration:
+                return generateNameForImportOrExportDeclaration(node);
+            case SyntaxKind.ExportAssignment:
+                return generateNameForExportDefault();
+            case SyntaxKind.ComputedPropertyName:
+                return makeTempVariableName(0 /* TempFlags.Auto */, /*reserveInNestedScopes*/ true);
+            default:
+                return makeTempVariableName(0 /* TempFlags.Auto */);
+        }
+    }
+    /**
+     * Generates a unique identifier for a node.
+     */
+    function makeName(name) {
+        switch (name.autoGenerateFlags & GeneratedIdentifierFlags.KindMask) {
+            case GeneratedIdentifierFlags.Auto:
+                return makeTempVariableName(0 /* TempFlags.Auto */, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes));
+            case GeneratedIdentifierFlags.Loop:
+                return makeTempVariableName(268435456 /* TempFlags._i */, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes));
+            case GeneratedIdentifierFlags.Unique:
+                return makeUniqueName(idText(name), (name.autoGenerateFlags & GeneratedIdentifierFlags.FileLevel) ? isFileLevelUniqueName : isUniqueName, !!(name.autoGenerateFlags & GeneratedIdentifierFlags.Optimistic), !!(name.autoGenerateFlags & GeneratedIdentifierFlags.ReservedInNestedScopes));
+        }
+        return Debug.fail("Unsupported GeneratedIdentifierKind.");
+    }
+    /**
+     * Gets the node from which a name should be generated.
+     */
+    function getNodeForGeneratedName(name) {
+        const autoGenerateId = name.autoGenerateId;
+        let node = name;
+        let original = node.original;
+        while (original) {
+            node = original;
+            // if "node" is a different generated name (having a different
+            // "autoGenerateId"), use it and stop traversing.
+            if (isIdentifier(node)
+                && !!(node.autoGenerateFlags & GeneratedIdentifierFlags.Node)
+                && node.autoGenerateId !== autoGenerateId) {
+                break;
+            }
+            original = node.original;
+        }
+        // otherwise, return the original node for the source;
+        return node;
+    }
+    // Comments
+    function pipelineEmitWithComments(hint, node) {
+        Debug.assert(lastNode === node);
+        hasWrittenComment = false;
+        const emitFlags = getEmitFlags(node);
+        const { pos, end } = getCommentRange(node);
+        const isEmittedNode = node.kind !== SyntaxKind.NotEmittedStatement;
+        // We have to explicitly check that the node is JsxText because if the compilerOptions.jsx is "preserve" we will not do any transformation.
+        // It is expensive to walk entire tree just to set one kind of node to have no comments.
+        const skipLeadingComments = pos < 0 || (emitFlags & EmitFlags.NoLeadingComments) !== 0 || node.kind === SyntaxKind.JsxText;
+        const skipTrailingComments = end < 0 || (emitFlags & EmitFlags.NoTrailingComments) !== 0 || node.kind === SyntaxKind.JsxText;
+        // Save current container state on the stack.
+        const savedContainerPos = containerPos;
+        const savedContainerEnd = containerEnd;
+        const savedDeclarationListContainerEnd = declarationListContainerEnd;
+        if ((pos > 0 || end > 0) && pos !== end) {
+            // Emit leading comments if the position is not synthesized and the node
+            // has not opted out from emitting leading comments.
+            if (!skipLeadingComments) {
+                emitLeadingComments(pos, isEmittedNode);
+            }
+            if (!skipLeadingComments || (pos >= 0 && (emitFlags & EmitFlags.NoLeadingComments) !== 0)) {
+                // Advance the container position if comments get emitted or if they've been disabled explicitly using NoLeadingComments.
+                containerPos = pos;
+            }
+            if (!skipTrailingComments || (end >= 0 && (emitFlags & EmitFlags.NoTrailingComments) !== 0)) {
+                // As above.
+                containerEnd = end;
+                // To avoid invalid comment emit in a down-level binding pattern, we
+                // keep track of the last declaration list container's end
+                if (node.kind === SyntaxKind.VariableDeclarationList) {
+                    declarationListContainerEnd = end;
+                }
+            }
+        }
+        forEach(getSyntheticLeadingComments(node), emitLeadingSynthesizedComment);
+        const pipelinePhase = getNextPipelinePhase(1 /* PipelinePhase.Comments */, hint, node);
+        if (emitFlags & EmitFlags.NoNestedComments) {
+            commentsDisabled = true;
+            pipelinePhase(hint, node);
+            commentsDisabled = false;
+        }
+        else {
+            pipelinePhase(hint, node);
+        }
+        forEach(getSyntheticTrailingComments(node), emitTrailingSynthesizedComment);
+        if ((pos > 0 || end > 0) && pos !== end) {
+            // Restore previous container state.
+            containerPos = savedContainerPos;
+            containerEnd = savedContainerEnd;
+            declarationListContainerEnd = savedDeclarationListContainerEnd;
+            // Emit trailing comments if the position is not synthesized and the node
+            // has not opted out from emitting leading comments and is an emitted node.
+            if (!skipTrailingComments && isEmittedNode) {
+                emitTrailingComments(end);
+            }
+        }
+        Debug.assert(lastNode === node);
+    }
+    function emitLeadingSynthesizedComment(comment) {
+        if (comment.kind === SyntaxKind.SingleLineCommentTrivia) {
+            writer.writeLine();
+        }
+        writeSynthesizedComment(comment);
+        if (comment.hasTrailingNewLine || comment.kind === SyntaxKind.SingleLineCommentTrivia) {
+            writer.writeLine();
+        }
+        else {
+            writer.writeSpace(" ");
+        }
+    }
+    function emitTrailingSynthesizedComment(comment) {
+        if (!writer.isAtStartOfLine()) {
+            writer.writeSpace(" ");
+        }
+        writeSynthesizedComment(comment);
+        if (comment.hasTrailingNewLine) {
+            writer.writeLine();
+        }
+    }
+    function writeSynthesizedComment(comment) {
+        const text = formatSynthesizedComment(comment);
+        const lineMap = comment.kind === SyntaxKind.MultiLineCommentTrivia ? computeLineStarts(text) : undefined;
+        writeCommentRange(text, lineMap, writer, 0, text.length, newLine);
+    }
+    function formatSynthesizedComment(comment) {
+        return comment.kind === SyntaxKind.MultiLineCommentTrivia
+            ? `/*${comment.text}*/`
+            : `//${comment.text}`;
+    }
+    function emitBodyWithDetachedComments(node, detachedRange, emitCallback) {
+        const { pos, end } = detachedRange;
+        const emitFlags = getEmitFlags(node);
+        const skipLeadingComments = pos < 0 || (emitFlags & EmitFlags.NoLeadingComments) !== 0;
+        const skipTrailingComments = commentsDisabled || end < 0 || (emitFlags & EmitFlags.NoTrailingComments) !== 0;
+        if (!skipLeadingComments) {
+            emitDetachedCommentsAndUpdateCommentsInfo(detachedRange);
+        }
+        if (emitFlags & EmitFlags.NoNestedComments && !commentsDisabled) {
+            commentsDisabled = true;
+            emitCallback(node);
+            commentsDisabled = false;
+        }
+        else {
+            emitCallback(node);
+        }
+        if (!skipTrailingComments) {
+            emitLeadingComments(detachedRange.end, /*isEmittedNode*/ true);
+            if (hasWrittenComment && !writer.isAtStartOfLine()) {
+                writer.writeLine();
+            }
+        }
+    }
+    function emitLeadingComments(pos, isEmittedNode) {
+        hasWrittenComment = false;
+        if (isEmittedNode) {
+            forEachLeadingCommentToEmit(pos, emitLeadingComment);
+        }
+    }
+    function emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) {
+        if (!hasWrittenComment) {
+            emitNewLineBeforeLeadingCommentOfPosition(getCurrentLineMap(), writer, rangePos, commentPos);
+            hasWrittenComment = true;
+        }
+        // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+        writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
+        if (hasTrailingNewLine) {
+            writer.writeLine();
+        }
+        else if (kind === SyntaxKind.MultiLineCommentTrivia) {
+            writer.writeSpace(" ");
+        }
+    }
+    function emitLeadingCommentsOfPosition(pos) {
+        if (commentsDisabled || pos === -1) {
+            return;
+        }
+        emitLeadingComments(pos, /*isEmittedNode*/ true);
+    }
+    function emitTrailingComments(pos) {
+        forEachTrailingCommentToEmit(pos, emitTrailingComment);
+    }
+    function emitTrailingComment(commentPos, commentEnd, _kind, hasTrailingNewLine) {
+        // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment2*/
+        if (!writer.isAtStartOfLine()) {
+            writer.writeSpace(" ");
+        }
+        writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
+        if (hasTrailingNewLine) {
+            writer.writeLine();
+        }
+    }
+    function emitTrailingCommentsOfPosition(pos, prefixSpace) {
+        if (commentsDisabled) {
+            return;
+        }
+        forEachTrailingCommentToEmit(pos, prefixSpace ? emitTrailingComment : emitTrailingCommentOfPosition);
+    }
+    function emitTrailingCommentOfPosition(commentPos, commentEnd, _kind, hasTrailingNewLine) {
+        // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space
+        writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
+        if (hasTrailingNewLine) {
+            writer.writeLine();
+        }
+        else {
+            writer.writeSpace(" ");
+        }
+    }
+    function forEachLeadingCommentToEmit(pos, cb) {
+        // Emit the leading comments only if the container's pos doesn't match because the container should take care of emitting these comments
+        if (currentSourceFile && (containerPos === -1 || pos !== containerPos)) {
+            if (hasDetachedComments(pos)) {
+                forEachLeadingCommentWithoutDetachedComments(cb);
+            }
+            else {
+                forEachLeadingCommentRange(currentSourceFile.text, pos, cb, /*state*/ pos);
+            }
+        }
+    }
+    function forEachTrailingCommentToEmit(end, cb) {
+        // Emit the trailing comments only if the container's end doesn't match because the container should take care of emitting these comments
+        if (currentSourceFile && (containerEnd === -1 || (end !== containerEnd && end !== declarationListContainerEnd))) {
+            forEachTrailingCommentRange(currentSourceFile.text, end, cb);
+        }
+    }
+    function hasDetachedComments(pos) {
+        return detachedCommentsInfo !== undefined && last(detachedCommentsInfo).nodePos === pos;
+    }
+    function forEachLeadingCommentWithoutDetachedComments(cb) {
+        // get the leading comments from detachedPos
+        const pos = last(detachedCommentsInfo).detachedCommentEndPos;
+        if (detachedCommentsInfo.length - 1) {
+            detachedCommentsInfo.pop();
+        }
+        else {
+            detachedCommentsInfo = undefined;
+        }
+        forEachLeadingCommentRange(currentSourceFile.text, pos, cb, /*state*/ pos);
+    }
+    function emitDetachedCommentsAndUpdateCommentsInfo(range) {
+        const currentDetachedCommentInfo = emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range, newLine, commentsDisabled);
+        if (currentDetachedCommentInfo) {
+            if (detachedCommentsInfo) {
+                detachedCommentsInfo.push(currentDetachedCommentInfo);
+            }
+            else {
+                detachedCommentsInfo = [currentDetachedCommentInfo];
+            }
+        }
+    }
+    function emitComment(text, lineMap, writer, commentPos, commentEnd, newLine) {
+        writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine);
+    }
+}
+function createBracketsMap() {
+    const brackets = [];
+    brackets[1024 /* ListFormat.Braces */] = ["{", "}"];
+    brackets[2048 /* ListFormat.Parenthesis */] = ["(", ")"];
+    brackets[4096 /* ListFormat.AngleBrackets */] = ["<", ">"];
+    brackets[8192 /* ListFormat.SquareBrackets */] = ["[", "]"];
+    return brackets;
+}
+function getOpeningBracket(format) {
+    return brackets[format & 15360 /* ListFormat.BracketsMask */][0];
+}
+function getClosingBracket(format) {
+    return brackets[format & 15360 /* ListFormat.BracketsMask */][1];
+}
+// Flags enum to track count of temp variables and a few dedicated names
+var TempFlags;
+(function (TempFlags) {
+    TempFlags[TempFlags["Auto"] = 0] = "Auto";
+    TempFlags[TempFlags["CountMask"] = 268435455] = "CountMask";
+    TempFlags[TempFlags["_i"] = 268435456] = "_i";
+})(TempFlags || (TempFlags = {}));