tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/printer.js

@@ -0,0 +1,4517 @@
+// Prints syntax trees as source text the way tsgo's printer does: formatting, comments,
+// source maps, generated names and emit helpers.
+import { ArrayLiteralExpression, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, ArrayTypeNode, getName, getParameters, getTypeParameters, getTypeArguments, getArguments, getElements, getProperties, getStatements, getModifiers, } from '../ast.js';
+import { computeLineOfPosition, computeLineStarts, getLeadingCommentRanges, getShebang, getTrailingCommentRanges, skipTrivia, tokenToString, } from '../scanner.js';
+import { ScriptTarget } from '../options.js';
+import { fileExtensionIs } from '../path.js';
+import { isWhiteSpaceLike } from '../character-codes.js';
+import { EmitContext, compareEmitHelpers } from './emit-context.js';
+import { NameGenerator, NameGeneratorHost, isFileLevelUniqueName } from './name-generator.js';
+import { TextWriter } from './text-writer.js';
+import { blockScopeFlags, calculateIndent, escapeString, getExpressionPrecedence, getLeftmostExpression, getLinesBetweenPositions, getLiteralText, getPreviousNonWhitespacePosition, getSourceFileOfNode, getSourceTextOfNode, getStartPositionOfRange, getTypeNodePrecedence, isBinaryOperation, isExpression, isImmediatelyInvokedFunctionExpressionOrArrowFunction, isJSDocKind, isJSDocLikeText, isKeywordKind, isLineBreakChar, isLiteralKind, isMemberName, isModifier, isNewExpressionWithoutArguments, isOptionalChain, isParseTreeNode, isPinnedComment, isPrologueDirective, isPunctuationKind, isRecognizedTripleSlashComment, isStatement, isTypeNodeKind, mixingBinaryOperatorsRequiresParentheses, nodeIsSynthesized, positionIsSynthesized, skipPartiallyEmittedExpressions, skipSynthesizedParentheses, trimUnicodeSpace, } from './utilities.js';
+export class PrinterOptions {
+    removeComments;
+    /** `"\n"` or `"\r\n"`. */
+    newLine;
+    noEmitHelpers;
+    target;
+    sourceMap;
+    inlineSourceMap;
+    inlineSources;
+    omitBraceSourceMapPositions;
+    /** Only keep JSDoc-style and pinned comments (declaration emit). */
+    onlyPrintJSDocStyle;
+    neverAsciiEscape;
+    preserveSourceNewlines;
+    terminateUnterminatedLiterals;
+    constructor() {
+        this.removeComments = false;
+        this.newLine = '\n';
+        this.noEmitHelpers = false;
+        this.target = ScriptTarget.ES5;
+        this.sourceMap = false;
+        this.inlineSourceMap = false;
+        this.inlineSources = false;
+        this.omitBraceSourceMapPositions = false;
+        this.onlyPrintJSDocStyle = false;
+        this.neverAsciiEscape = false;
+        this.preserveSourceNewlines = false;
+        this.terminateUnterminatedLiterals = false;
+    }
+}
+export class Printer extends NameGeneratorHost {
+    options;
+    context;
+    /**
+     * Generates the names of the printed file, created when first needed: it refers back to the printer (its host),
+     * and printing a type node never generates names.
+     */
+    nameGeneratorStore = undefined;
+    currentSourceFile;
+    sourceText;
+    lineStarts;
+    writer;
+    ownWriter;
+    uniqueHelperNames;
+    externalHelpersModuleName;
+    nextListElementPos;
+    containerPos;
+    containerEnd;
+    declarationListContainerEnd;
+    /** Pairs of (node pos, end of its detached comments). */
+    detachedComments;
+    commentsDisabled;
+    /** Emitting the `extends` clause of a conditional or infer type. */
+    inExtends;
+    /** Saved comment state: emit flags, comment pos, comment end, container pos, container end, declaration list end. */
+    commentStack;
+    /** Saved source map state: emit flags, pos, end, has token range. */
+    sourceMapStack;
+    /** The token position after `enterToken` skipped trivia. */
+    tokenPos;
+    sourceMapsDisabled;
+    sourceMapGenerator;
+    sourceMapSource;
+    sourceMapSourceIndex;
+    sourceMapSourceIsJson;
+    sourceMapLineStarts;
+    /** The line of the last source map position, where finding the next one's starts. */
+    sourceMapLine;
+    mostRecentSourceMapSource;
+    mostRecentSourceMapSourceIndex;
+    get nameGenerator() {
+        let generator = this.nameGeneratorStore;
+        if (generator === undefined) {
+            generator = new NameGenerator(this.context, this);
+            this.nameGeneratorStore = generator;
+        }
+        return generator;
+    }
+    constructor(options, context) {
+        super();
+        this.options = options;
+        this.context = context === undefined ? new EmitContext() : context;
+        this.currentSourceFile = undefined;
+        this.sourceText = '';
+        this.lineStarts = [];
+        this.writer = new TextWriter(options.newLine, 4);
+        this.ownWriter = undefined;
+        this.uniqueHelperNames = undefined;
+        this.externalHelpersModuleName = undefined;
+        this.nextListElementPos = 0;
+        this.containerPos = -1;
+        this.containerEnd = -1;
+        this.declarationListContainerEnd = -1;
+        this.detachedComments = [];
+        this.commentsDisabled = options.removeComments;
+        this.inExtends = false;
+        this.commentStack = [];
+        this.sourceMapStack = [];
+        this.tokenPos = 0;
+        this.sourceMapsDisabled = true;
+        this.sourceMapGenerator = undefined;
+        this.sourceMapSource = undefined;
+        this.sourceMapSourceIndex = -1;
+        this.sourceMapSourceIsJson = false;
+        this.sourceMapLineStarts = [];
+        this.sourceMapLine = 0;
+        this.mostRecentSourceMapSource = undefined;
+        this.mostRecentSourceMapSourceIndex = -1;
+    }
+    // Entry points
+    /** Prints `node` (in the context of `sourceFile`, if given) and returns the text. */
+    emit(node, sourceFile) {
+        let writer = this.ownWriter;
+        if (writer === undefined) {
+            writer = new TextWriter(this.options.newLine, 4);
+            this.ownWriter = writer;
+        }
+        this.write(node, sourceFile, writer, undefined);
+        const text = writer.getText();
+        writer.clear();
+        return text;
+    }
+    emitSourceFile(sourceFile) {
+        return this.emit(sourceFile, sourceFile);
+    }
+    setSourceFile(sourceFile) {
+        this.setCurrentSourceFile(sourceFile);
+        this.uniqueHelperNames = undefined;
+        this.externalHelpersModuleName = undefined;
+        if (sourceFile !== undefined) {
+            if ((this.context.getEmitFlags(this.context.mostOriginal(sourceFile)) & 262144 /* EmitFlags.ExternalHelpers */) !== 0)
+                this.uniqueHelperNames = new Map();
+            this.externalHelpersModuleName = this.context.getExternalHelpersModuleName(sourceFile);
+            this.setSourceMapSource(sourceFile);
+        }
+        return true;
+    }
+    setCurrentSourceFile(sourceFile) {
+        this.currentSourceFile = sourceFile;
+        this.sourceText = sourceFile === undefined ? '' : sourceFile.text;
+        this.lineStarts = sourceFile === undefined ? [] : sourceFile.lineStarts();
+        return true;
+    }
+    /** Prints `node` into `writer`, adding mappings to `sourceMapGenerator` if given. */
+    write(node, sourceFile, writer, sourceMapGenerator) {
+        const savedSourceFile = this.currentSourceFile;
+        const savedWriter = this.writer;
+        const savedUniqueHelperNames = this.uniqueHelperNames;
+        const savedSourceMapsDisabled = this.sourceMapsDisabled;
+        const savedGenerator = this.sourceMapGenerator;
+        const savedSource = this.sourceMapSource;
+        const savedSourceIndex = this.sourceMapSourceIndex;
+        const savedSourceLineStarts = this.sourceMapLineStarts;
+        this.sourceMapsDisabled = sourceMapGenerator === undefined;
+        this.sourceMapGenerator = sourceMapGenerator;
+        this.sourceMapSource = undefined;
+        this.sourceMapSourceIndex = -1;
+        this.sourceMapLineStarts = [];
+        this.sourceMapLine = 0;
+        this.setSourceFile(sourceFile);
+        this.writer = writer;
+        writer.clear();
+        writer.trackColumns = sourceMapGenerator !== undefined;
+        this.emitAnyNode(node);
+        this.setCurrentSourceFile(savedSourceFile);
+        this.writer = savedWriter;
+        this.uniqueHelperNames = savedUniqueHelperNames;
+        this.sourceMapsDisabled = savedSourceMapsDisabled;
+        this.sourceMapGenerator = savedGenerator;
+        this.sourceMapSource = savedSource;
+        this.sourceMapSourceIndex = savedSourceIndex;
+        this.sourceMapLineStarts = savedSourceLineStarts;
+        this.sourceMapLine = 0;
+        return true;
+    }
+    // Text of nodes
+    isFileLevelUniqueName(name) {
+        const file = this.currentSourceFile;
+        return file === undefined || isFileLevelUniqueName(file, name);
+    }
+    getLiteralTextOfNode(node, sourceFile, flags) {
+        if (node instanceof StringLiteral) {
+            const textSource = this.context.textSource.get(node);
+            if (textSource !== undefined) {
+                let text;
+                if (textSource instanceof NumericLiteral)
+                    text = textSource.text;
+                else if (textSource instanceof Identifier ||
+                    textSource instanceof PrivateIdentifier ||
+                    textSource instanceof JsxNamespacedName)
+                    text = this.getTextOfNode(textSource);
+                else
+                    return this.getLiteralTextOfNode(textSource, getSourceFileOfNode(textSource), flags);
+                if ((flags & 2 /* LiteralTextFlags.JsxAttributeEscape */) !== 0)
+                    return ('"' +
+                        escapeString(text, 0x22, 2 /* LiteralTextFlags.JsxAttributeEscape */ | 1 /* LiteralTextFlags.NeverAsciiEscape */) +
+                        '"');
+                if ((flags & 1 /* LiteralTextFlags.NeverAsciiEscape */) !== 0 ||
+                    (this.context.getEmitFlags(node) & 131072 /* EmitFlags.NoAsciiEscaping */) !== 0)
+                    return '"' + escapeString(text, 0x22, 1 /* LiteralTextFlags.NeverAsciiEscape */) + '"';
+                return '"' + escapeString(text, 0x22, 0 /* LiteralTextFlags.None */) + '"';
+            }
+        }
+        if ((this.context.getEmitFlags(node) & 131072 /* EmitFlags.NoAsciiEscaping */) !== 0)
+            flags |= 1 /* LiteralTextFlags.NeverAsciiEscape */;
+        if (this.options.target >= ScriptTarget.ES2021)
+            flags |= 8 /* LiteralTextFlags.AllowNumericSeparator */;
+        const file = sourceFile === undefined ? this.currentSourceFile : sourceFile;
+        return getLiteralText(node, file === undefined ? undefined : file.text, flags);
+    }
+    /** The text of an identifier, private identifier, literal or JSX namespaced name as printed. */
+    getTextOfNode(node) {
+        if ((node instanceof Identifier || node instanceof PrivateIdentifier) && this.context.autoGenerate.has(node))
+            return this.nameGenerator.generateName(node);
+        if (node instanceof StringLiteral) {
+            const textSource = this.context.textSource.get(node);
+            if (textSource !== undefined)
+                return this.getTextOfNode(textSource);
+        }
+        const file = this.currentSourceFile;
+        const canUseSourceFile = file !== undefined && node.parent !== undefined && !nodeIsSynthesized(node);
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+            case 296 /* SyntaxKind.JsxNamespacedName */:
+                if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
+                    if (node instanceof Identifier)
+                        return node.text;
+                    if (node instanceof PrivateIdentifier)
+                        return node.text;
+                    if (node instanceof JsxNamespacedName)
+                        return node.namespace.text + ':' + node.name.text;
+                }
+                break;
+            case 10 /* SyntaxKind.StringLiteral */:
+            case 8 /* SyntaxKind.NumericLiteral */:
+            case 9 /* SyntaxKind.BigIntLiteral */:
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+            case 15 /* SyntaxKind.TemplateHead */:
+            case 16 /* SyntaxKind.TemplateMiddle */:
+            case 17 /* SyntaxKind.TemplateTail */:
+                return this.getLiteralTextOfNode(node, undefined, 0 /* LiteralTextFlags.None */);
+            default:
+                throw new Error('Unexpected node kind ' + node.kind);
+        }
+        return getSourceTextOfNode(this.sourceText, node);
+    }
+    isInCurrentSourceFile(node) {
+        const file = this.currentSourceFile;
+        if (file === undefined)
+            return false;
+        const original = this.context.mostOriginal(file);
+        const own = getSourceFileOfNode(node);
+        return own !== undefined && own === original;
+    }
+    // Low-level writing
+    write1(text) {
+        return this.writer.write(text);
+    }
+    space() {
+        return this.writer.write(' ');
+    }
+    line() {
+        return this.writer.writeLine(false);
+    }
+    lines(count) {
+        for (let i = 0; i < count; i++)
+            this.writer.writeLine(false);
+        return count > 0;
+    }
+    indentIf(condition, delta) {
+        if (condition)
+            this.writer.indent += delta;
+        return condition;
+    }
+    writeLinesOfText(text) {
+        const lines = splitLines(text);
+        const indentation = guessIndentation(lines);
+        for (const text of lines) {
+            const line = indentation > 0 ? text.substring(indentation) : text;
+            if (line.length > 0) {
+                this.line();
+                this.write1(line);
+            }
+        }
+        return true;
+    }
+    writeLineOrSpace(parent, prev, next) {
+        if (this.shouldEmitOnSingleLine(parent))
+            return this.space();
+        if (this.options.preserveSourceNewlines) {
+            const lines = this.getLinesBetweenNodes(parent, prev, next);
+            return lines > 0 ? this.lines(lines) : this.space();
+        }
+        return this.line();
+    }
+    writeLinesAndIndent(lineCount, writeSpaceIfNotIndenting) {
+        if (lineCount > 0) {
+            this.writer.indent++;
+            this.lines(lineCount);
+        }
+        else if (writeSpaceIfNotIndenting)
+            this.space();
+        return true;
+    }
+    writeLineSeparatorsAndIndentBefore(node, parent) {
+        if (this.options.preserveSourceNewlines) {
+            const leading = this.getLeadingLineTerminatorCount(parent, node, 0 /* ListFormat.None */);
+            if (leading > 0) {
+                this.writeLinesAndIndent(leading, false);
+                return true;
+            }
+        }
+        return false;
+    }
+    writeLineSeparatorsAfter(node, parent) {
+        if (this.options.preserveSourceNewlines)
+            return this.lines(this.getClosingLineTerminatorCount(parent, node, 0 /* ListFormat.None */, -1));
+        return false;
+    }
+    // Lines between nodes
+    positionsAreOnSameLine(pos1, pos2) {
+        return getLinesBetweenPositions(this.lineStarts, pos1, pos2) === 0;
+    }
+    rangeStart(pos) {
+        return getStartPositionOfRange(this.sourceText, pos, false);
+    }
+    rangeIsOnSingleLine(node) {
+        return this.positionsAreOnSameLine(this.rangeStart(node.pos), node.end);
+    }
+    rangeEndIsOnSameLineAsRangeStart(end, start) {
+        return this.positionsAreOnSameLine(end, this.rangeStart(start));
+    }
+    getEffectiveLinesBetweenEndAndStart(end, start) {
+        const lines = getLinesBetweenPositions(this.lineStarts, end, getStartPositionOfRange(this.sourceText, start, true));
+        if (lines !== 0)
+            return lines;
+        return getLinesBetweenPositions(this.lineStarts, end, getStartPositionOfRange(this.sourceText, start, false));
+    }
+    getLinesBetweenNodes(parent, node1, node2) {
+        if (this.shouldElideIndentation(parent))
+            return 0;
+        parent = skipSynthesizedParentheses(parent);
+        node1 = skipSynthesizedParentheses(node1);
+        node2 = skipSynthesizedParentheses(node2);
+        if (this.shouldEmitOnNewLine(node2, 0 /* ListFormat.None */))
+            return 1;
+        if (this.currentSourceFile !== undefined &&
+            !nodeIsSynthesized(parent) &&
+            !nodeIsSynthesized(node1) &&
+            !nodeIsSynthesized(node2)) {
+            if (this.options.preserveSourceNewlines)
+                return this.getEffectiveLinesBetweenEndAndStart(node1.end, node2.pos);
+            return this.rangeEndIsOnSameLineAsRangeStart(node1.end, node2.pos) ? 0 : 1;
+        }
+        return 0;
+    }
+    linesToPrecedingNonWhitespace(pos, stopPos, includeComments) {
+        const start = skipTrivia(this.sourceText, pos, false, includeComments);
+        const prev = getPreviousNonWhitespacePosition(this.sourceText, start, stopPos);
+        return getLinesBetweenPositions(this.lineStarts, prev >= 0 ? prev : stopPos, start);
+    }
+    linesToNextNonWhitespace(pos, stopPos, includeComments) {
+        const next = skipTrivia(this.sourceText, pos, false, includeComments);
+        return getLinesBetweenPositions(this.lineStarts, pos, stopPos < next ? stopPos : next);
+    }
+    getLeadingLineTerminatorCount(parent, firstChild, format) {
+        if ((format & 2 /* ListFormat.PreserveLines */) !== 0 || this.options.preserveSourceNewlines) {
+            if ((format & 65536 /* ListFormat.PreferNewLine */) !== 0)
+                return 1;
+            if (firstChild === undefined)
+                return parent === undefined || (this.currentSourceFile !== undefined && this.rangeIsOnSingleLine(parent))
+                    ? 0
+                    : 1;
+            if (this.nextListElementPos > 0 && firstChild.pos === this.nextListElementPos)
+                return 0;
+            if (firstChild.kind === 11 /* SyntaxKind.JsxText */)
+                return 0;
+            if (this.currentSourceFile !== undefined &&
+                parent !== undefined &&
+                !positionIsSynthesized(parent.pos) &&
+                !nodeIsSynthesized(firstChild) &&
+                firstChild.parent === undefined) {
+                if (this.options.preserveSourceNewlines) {
+                    const lines = this.linesToPrecedingNonWhitespace(firstChild.pos, parent.pos, true);
+                    return lines !== 0 ? lines : this.linesToPrecedingNonWhitespace(firstChild.pos, parent.pos, false);
+                }
+                return this.positionsAreOnSameLine(this.rangeStart(parent.pos), this.rangeStart(firstChild.pos)) ? 0 : 1;
+            }
+            if (this.shouldEmitOnNewLine(firstChild, format))
+                return 1;
+        }
+        return (format & 1 /* ListFormat.MultiLine */) !== 0 ? 1 : 0;
+    }
+    getSeparatingLineTerminatorCount(previous, next, format) {
+        if ((format & 2 /* ListFormat.PreserveLines */) !== 0 || this.options.preserveSourceNewlines) {
+            if (previous === undefined || next === undefined)
+                return 0;
+            if (next.kind === 11 /* SyntaxKind.JsxText */)
+                return 0;
+            if (this.currentSourceFile !== undefined && !nodeIsSynthesized(previous) && !nodeIsSynthesized(next)) {
+                if (this.options.preserveSourceNewlines && this.siblingNodePositionsAreComparable(previous, next))
+                    return this.getEffectiveLinesBetweenEndAndStart(previous.end, next.pos);
+                if (!this.options.preserveSourceNewlines && this.originalNodesHaveSameParent(previous, next))
+                    return this.rangeEndIsOnSameLineAsRangeStart(previous.end, next.pos) ? 0 : 1;
+                return (format & 65536 /* ListFormat.PreferNewLine */) !== 0 ? 1 : 0;
+            }
+            if (this.shouldEmitOnNewLine(previous, format) || this.shouldEmitOnNewLine(next, format))
+                return 1;
+        }
+        else if (next !== undefined && this.shouldEmitOnNewLine(next, 0 /* ListFormat.None */))
+            return 1;
+        return (format & 1 /* ListFormat.MultiLine */) !== 0 ? 1 : 0;
+    }
+    getClosingLineTerminatorCount(parent, lastChild, format, childrenEnd) {
+        if ((format & 2 /* ListFormat.PreserveLines */) !== 0 || this.options.preserveSourceNewlines) {
+            if ((format & 65536 /* ListFormat.PreferNewLine */) !== 0)
+                return 1;
+            if (lastChild === undefined)
+                return parent === undefined || (this.currentSourceFile !== undefined && this.rangeIsOnSingleLine(parent))
+                    ? 0
+                    : 1;
+            if (this.currentSourceFile !== undefined &&
+                parent !== undefined &&
+                !positionIsSynthesized(parent.pos) &&
+                !nodeIsSynthesized(lastChild) &&
+                (lastChild.parent === undefined || lastChild.parent === parent)) {
+                if (this.options.preserveSourceNewlines) {
+                    const end = childrenEnd > lastChild.end ? childrenEnd : lastChild.end;
+                    const lines = this.linesToNextNonWhitespace(end, parent.end, true);
+                    return lines !== 0 ? lines : this.linesToNextNonWhitespace(end, parent.end, false);
+                }
+                return this.positionsAreOnSameLine(parent.end, lastChild.end) ? 0 : 1;
+            }
+            if (this.shouldEmitOnNewLine(lastChild, format))
+                return 1;
+        }
+        if ((format & 1 /* ListFormat.MultiLine */) !== 0 && (format & 131072 /* ListFormat.NoTrailingNewLine */) === 0)
+            return 1;
+        return 0;
+    }
+    siblingNodePositionsAreComparable(previous, next) {
+        if (next.pos < previous.end)
+            return false;
+        previous = this.context.mostOriginal(previous);
+        next = this.context.mostOriginal(next);
+        const parent = previous.parent;
+        if (parent === undefined || parent !== next.parent)
+            return false;
+        const list = getContainingNodeArray(previous);
+        if (list === undefined)
+            return false;
+        const index = list.nodes.indexOf(previous);
+        return index >= 0 && list.nodes.indexOf(next) === index + 1;
+    }
+    originalNodesHaveSameParent(a, b) {
+        a = this.context.mostOriginal(a);
+        if (a.parent === undefined)
+            return false;
+        return a.parent === this.context.mostOriginal(b).parent;
+    }
+    // Comment text
+    writeCommentRange(comment) {
+        if (this.currentSourceFile === undefined)
+            return false;
+        return this.writeCommentText(this.sourceText, this.lineStarts, comment.kind, comment.pos, comment.end);
+    }
+    writeCommentText(text, lineStarts, kind, pos, end) {
+        if (kind !== 3 /* SyntaxKind.MultiLineCommentTrivia */)
+            return this.writer.writeComment(text.substring(pos, end));
+        const writer = this.writer;
+        const firstLine = computeLineOfPosition(lineStarts, pos);
+        const lineCount = lineStarts.length;
+        let firstCommentLineIndent = -1;
+        const start = pos;
+        for (let currentLine = firstLine; pos < end; currentLine++) {
+            const nextLineStart = currentLine + 1 === lineCount ? text.length + 1 : lineStarts[currentLine + 1] | 0;
+            if (pos !== start) {
+                if (firstCommentLineIndent === -1)
+                    firstCommentLineIndent = calculateIndent(text, lineStarts[firstLine] | 0, start);
+                const spacesToEmit = writer.indent * 4 - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart);
+                if (spacesToEmit > 0) {
+                    const singleSpaces = spacesToEmit & 3;
+                    writer.rawWrite(' '.repeat(spacesToEmit - singleSpaces));
+                    for (let i = 0; i < singleSpaces; i++)
+                        writer.rawWrite(' ');
+                }
+                else
+                    writer.rawWrite('');
+            }
+            // Line starts split at every line break, so only the end of the line can hold one.
+            let lineEnd = end < nextLineStart ? end : nextLineStart;
+            while (lineEnd > pos && isLineBreakChar(text.charCodeAt(lineEnd - 1)))
+                lineEnd -= 1;
+            const lineText = trimUnicodeSpace(text, pos, lineEnd);
+            if (lineText.length > 0) {
+                writer.writeComment(lineText);
+                if (lineEnd !== end)
+                    writer.writeLine(false);
+            }
+            else
+                writer.writeLine(true);
+            pos = nextLineStart;
+        }
+        return true;
+    }
+    // Emit flags
+    shouldEmitComments(node) {
+        return !this.commentsDisabled && this.currentSourceFile !== undefined && node.kind !== 307 /* SyntaxKind.SourceFile */;
+    }
+    shouldWriteComment(comment) {
+        return (!this.options.onlyPrintJSDocStyle ||
+            (this.currentSourceFile !== undefined &&
+                (isJSDocLikeText(this.sourceText, comment) || isPinnedComment(this.sourceText, comment))));
+    }
+    hasEmitFlag(node, flag) {
+        return (this.context.getEmitFlags(node) & flag) !== 0;
+    }
+    shouldEmitIndented(node) {
+        return this.hasEmitFlag(node, 8192 /* EmitFlags.Indented */);
+    }
+    shouldElideIndentation(node) {
+        return this.hasEmitFlag(node, 16384 /* EmitFlags.NoIndentation */);
+    }
+    shouldEmitOnSingleLine(node) {
+        return this.hasEmitFlag(node, 1 /* EmitFlags.SingleLine */);
+    }
+    shouldEmitOnNewLine(node, format) {
+        return this.hasEmitFlag(node, 524288 /* EmitFlags.StartOnNewLine */) || (format & 65536 /* ListFormat.PreferNewLine */) !== 0;
+    }
+    shouldEmitBlockFunctionBodyOnSingleLine(body) {
+        if (this.shouldEmitOnSingleLine(body))
+            return true;
+        if (body.multiLine)
+            return false;
+        if (!nodeIsSynthesized(body) && this.currentSourceFile !== undefined && !this.rangeIsOnSingleLine(body))
+            return false;
+        const statements = body.statements.nodes;
+        if (this.getLeadingLineTerminatorCount(body, statements.length > 0 ? statements[0] : undefined, 2 /* ListFormat.PreserveLines */) > 0 ||
+            this.getClosingLineTerminatorCount(body, statements.length > 0 ? statements[statements.length - 1] : undefined, 2 /* ListFormat.PreserveLines */, body.statements.end) > 0)
+            return false;
+        let previous = undefined;
+        for (const statement of statements) {
+            if (this.getSeparatingLineTerminatorCount(previous, statement, 2 /* ListFormat.PreserveLines */) > 0)
+                return false;
+            previous = statement;
+        }
+        return true;
+    }
+    shouldEmitSourceMaps(node) {
+        return (!this.sourceMapsDisabled &&
+            this.sourceMapSource !== undefined &&
+            node.kind !== 307 /* SyntaxKind.SourceFile */ &&
+            (node.flags & 33554432 /* NodeFlags.JsonFile */) === 0);
+    }
+    shouldAllowTrailingComma(node) {
+        return (this.currentSourceFile !== undefined &&
+            this.currentSourceFile.scriptKind !== 6 /* ScriptKind.JSON */ &&
+            node.kind === 211 /* SyntaxKind.ObjectLiteralExpression */);
+    }
+    hasCommentsAtPosition(pos) {
+        if (this.currentSourceFile === undefined)
+            return false;
+        return (getTrailingCommentRanges(this.sourceText, pos + 1) !== undefined ||
+            getLeadingCommentRanges(this.sourceText, pos + 1) !== undefined);
+    }
+    // Tokens
+    writeTokenText(token, pos) {
+        const text = tokenToString(token);
+        this.writer.write(text);
+        return pos < 0 ? pos : pos + text.length;
+    }
+    emitToken(token, pos, contextNode) {
+        return this.emitTokenEx(token, pos, contextNode, 0 /* TokenEmitFlags.None */);
+    }
+    emitTokenEx(token, pos, contextNode, flags) {
+        const state = this.enterToken(token, pos, contextNode, flags);
+        pos = this.writeTokenText(token, this.tokenPos);
+        this.exitToken(token, pos, contextNode, state);
+        return pos;
+    }
+    emitOptionalToken(node) {
+        return node !== undefined && this.emitTokenNodeEx(node, 0 /* TokenEmitFlags.None */);
+    }
+    emitTokenNode(node) {
+        return this.emitTokenNodeEx(node, 0 /* TokenEmitFlags.None */);
+    }
+    emitTokenNodeEx(node, flags) {
+        if (!isKeywordKind(node.kind) && !isPunctuationKind(node.kind))
+            throw new Error('Unexpected token ' + node.kind);
+        const state = this.enterTokenNode(node, flags);
+        this.writeTokenText(node.kind, node.pos);
+        this.exitTokenNode(node, state);
+        return true;
+    }
+    // Literals
+    emitLiteral(node) {
+        let flags = 0 /* LiteralTextFlags.None */;
+        if (this.options.neverAsciiEscape)
+            flags |= 1 /* LiteralTextFlags.NeverAsciiEscape */;
+        if (this.options.terminateUnterminatedLiterals)
+            flags |= 4 /* LiteralTextFlags.TerminateUnterminatedLiterals */;
+        const state = this.enterNode(node);
+        this.writer.writeText(this.getLiteralTextOfNode(node, undefined, flags));
+        this.exitNode(node, state);
+        return true;
+    }
+    // Names
+    // Source text of names reparsed from JSDoc can span lines.
+    emitIdentifierText(node) {
+        return this.writer.writeText(this.getTextOfNode(node));
+    }
+    emitIdentifierName(node) {
+        const state = this.enterNode(node);
+        this.emitIdentifierText(node);
+        this.exitNode(node, state);
+        return true;
+    }
+    getUniqueHelperName(name) {
+        const names = this.uniqueHelperNames;
+        const existing = names.get(name);
+        if (existing !== undefined)
+            return this.context.factory.cloneIdentifier(existing);
+        const helperName = this.context.factory.createUniqueName(name, 32 /* GeneratedIdentifierFlags.FileLevel */ | 16 /* GeneratedIdentifierFlags.Optimistic */);
+        this.nameGenerator.generateName(helperName);
+        names.set(name, helperName);
+        return helperName;
+    }
+    emitIdentifierReference(node) {
+        if ((this.externalHelpersModuleName !== undefined || this.uniqueHelperNames !== undefined) &&
+            this.hasEmitFlag(node, 1024 /* EmitFlags.HelperName */)) {
+            const moduleName = this.externalHelpersModuleName;
+            if (moduleName !== undefined) {
+                const factory = this.context.factory;
+                const helper = factory.createPropertyAccessExpression(factory.cloneIdentifier(moduleName), factory.cloneIdentifier(node));
+                this.context.assignCommentAndSourceMapRanges(helper, node);
+                return this.emitPropertyAccessExpression(helper);
+            }
+            const helperName = this.getUniqueHelperName(node.text);
+            this.context.assignCommentAndSourceMapRanges(helperName, node);
+            node = helperName;
+        }
+        return this.emitIdentifierName(node);
+    }
+    emitBindingIdentifier(node) {
+        if (this.uniqueHelperNames !== undefined && this.hasEmitFlag(node, 1024 /* EmitFlags.HelperName */)) {
+            const helperName = this.getUniqueHelperName(node.text);
+            this.context.assignCommentAndSourceMapRanges(helperName, node);
+            node = helperName;
+        }
+        return this.emitIdentifierName(node);
+    }
+    emitPrivateIdentifier(node) {
+        const state = this.enterNode(node);
+        this.writer.writeText(this.getTextOfNode(node));
+        this.exitNode(node, state);
+        return true;
+    }
+    emitQualifiedName(node) {
+        const state = this.enterNode(node);
+        this.emitEntityName(node.left);
+        this.write1('.');
+        this.emitIdentifierName(node.right);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitComputedPropertyName(node) {
+        const state = this.enterNode(node);
+        this.write1('[');
+        this.emitExpression(node.expression, 2 /* OperatorPrecedence.DisallowComma */);
+        this.write1(']');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitEntityName(node) {
+        if (node instanceof Identifier)
+            return this.emitIdentifierReference(node);
+        if (node instanceof QualifiedName)
+            return this.emitQualifiedName(node);
+        if (node instanceof PropertyAccessExpression)
+            return this.emitExpression(node, 2 /* OperatorPrecedence.DisallowComma */);
+        throw new Error('Unexpected entity name ' + node.kind);
+    }
+    emitBindingName(node) {
+        if (node === undefined)
+            return false;
+        if (node instanceof Identifier)
+            return this.emitBindingIdentifier(node);
+        if (node instanceof BindingPattern)
+            return this.emitBindingPattern(node);
+        throw new Error('Unexpected binding name ' + node.kind);
+    }
+    emitPropertyName(node) {
+        if (node === undefined)
+            return false;
+        if (node instanceof Identifier)
+            return this.emitIdentifierName(node);
+        if (node instanceof PrivateIdentifier)
+            return this.emitPrivateIdentifier(node);
+        if (node instanceof ComputedPropertyName)
+            return this.emitComputedPropertyName(node);
+        if (isLiteralKind(node.kind))
+            return this.emitLiteral(node);
+        throw new Error('Unexpected property name ' + node.kind);
+    }
+    emitMemberName(node) {
+        if (node instanceof Identifier)
+            return this.emitIdentifierName(node);
+        if (node instanceof PrivateIdentifier)
+            return this.emitPrivateIdentifier(node);
+        throw new Error('Unexpected member name ' + node.kind);
+    }
+    /** Module names, module export names, import attribute names and nested module names. */
+    emitIdentifierOrString(node, binding) {
+        if (node instanceof Identifier)
+            return binding ? this.emitBindingIdentifier(node) : this.emitIdentifierName(node);
+        if (node instanceof StringLiteral)
+            return this.emitLiteral(node);
+        throw new Error('Unexpected name ' + node.kind);
+    }
+    // Signature elements
+    emitModifierList(parent, modifiers, allowDecorators) {
+        if (modifiers === undefined || modifiers.nodes.length === 0)
+            return parent.pos;
+        const nodes = modifiers.nodes;
+        let allModifiers = true;
+        let allDecorators = true;
+        for (const n of nodes) {
+            if (n.kind === 171 /* SyntaxKind.Decorator */)
+                allModifiers = false;
+            else
+                allDecorators = false;
+            if (!isModifier(n))
+                allModifiers = false;
+        }
+        if (allModifiers)
+            this.emitList(0 /* ListItem.Keyword */, parent, modifiers, 2359808 /* ListFormat.Modifiers */);
+        else if (allDecorators) {
+            if (!allowDecorators)
+                return parent.pos;
+            this.emitList(1 /* ListItem.ModifierLike */, parent, modifiers, 2146305 /* ListFormat.Decorators */);
+        }
+        else {
+            // Emit runs of modifiers and decorators with their own formats.
+            let lastDecorators = false;
+            let decorators = false;
+            let haveMode = false;
+            let start = 0;
+            let pos = 0;
+            while (start < nodes.length) {
+                while (pos < nodes.length) {
+                    decorators = nodes[pos].kind === 171 /* SyntaxKind.Decorator */;
+                    if (!haveMode) {
+                        lastDecorators = decorators;
+                        haveMode = true;
+                    }
+                    else if (decorators !== lastDecorators)
+                        break;
+                    pos++;
+                }
+                const rangePos = start === 0 ? modifiers.pos : -1;
+                const rangeEnd = pos === nodes.length - 1 ? modifiers.end : -1;
+                if (allowDecorators || !lastDecorators)
+                    this.emitListItems(1 /* ListItem.ModifierLike */, parent, nodes, start, pos, lastDecorators ? 2146305 /* ListFormat.Decorators */ : 2359808 /* ListFormat.Modifiers */, false, rangePos, rangeEnd);
+                start = pos;
+                lastDecorators = decorators;
+                pos++;
+            }
+        }
+        const last = nodes[nodes.length - 1];
+        return last.end > parent.pos ? last.end : parent.pos;
+    }
+    emitTypeParameter(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.emitBindingIdentifier(node.name);
+        if (node.constraint !== undefined) {
+            this.write1(' extends ');
+            this.emitTypeNodeOutsideExtends(node.constraint);
+        }
+        if (node.defaultType !== undefined) {
+            this.write1(' = ');
+            this.emitTypeNodeOutsideExtends(node.defaultType);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitParameter(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, true);
+        this.emitOptionalToken(node.dotDotDotToken);
+        this.emitBindingName(node.name);
+        this.emitOptionalToken(node.questionToken);
+        this.emitTypeAnnotation(node.type);
+        let end = node.pos;
+        if (node.modifiers !== undefined && node.modifiers.end > end)
+            end = node.modifiers.end;
+        if (node.name.end > end)
+            end = node.name.end;
+        if (node.questionToken !== undefined && node.questionToken.end > end)
+            end = node.questionToken.end;
+        if (node.type !== undefined && node.type.end > end)
+            end = node.type.end;
+        this.emitInitializer(node.initializer, end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitDecorator(node) {
+        const state = this.enterNode(node);
+        this.write1('@');
+        this.emitExpression(node.expression, 18 /* OperatorPrecedence.LeftHandSide */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTypeParameters(parent, nodes) {
+        if (nodes === undefined)
+            return false;
+        return this.emitList(2 /* ListItem.TypeParameter */, parent, nodes, 53776 /* ListFormat.TypeParameters */ | (parent.kind === 220 /* SyntaxKind.ArrowFunction */ ? 64 /* ListFormat.AllowTrailingComma */ : 0));
+    }
+    emitTypeAnnotation(node) {
+        if (node === undefined)
+            return false;
+        this.write1(': ');
+        return this.emitTypeNodeOutsideExtends(node);
+    }
+    emitInitializer(node, equalsPos, contextNode) {
+        if (node === undefined)
+            return false;
+        this.space();
+        this.emitToken(63 /* SyntaxKind.EqualsToken */, equalsPos, contextNode);
+        this.space();
+        return this.emitExpression(node, 2 /* OperatorPrecedence.DisallowComma */);
+    }
+    emitParameters(parent, parameters) {
+        this.generateAllNames(parameters);
+        return this.emitList(3 /* ListItem.Parameter */, parent, parameters, 2576 /* ListFormat.Parameters */);
+    }
+    canEmitSimpleArrowHead(parent, parameters) {
+        if (!(parent instanceof ArrowFunction) || parameters.nodes.length !== 1)
+            return false;
+        const parameter = parameters.nodes[0];
+        return (parameter instanceof ParameterDeclaration &&
+            parameter.pos === parent.pos &&
+            parent.typeParameters === undefined &&
+            parent.type === undefined &&
+            (parent.modifiers === undefined || parent.modifiers.nodes.length === 0) &&
+            !parameters.hasTrailingComma() &&
+            parameter.modifiers === undefined &&
+            parameter.dotDotDotToken === undefined &&
+            parameter.questionToken === undefined &&
+            parameter.type === undefined &&
+            parameter.initializer === undefined &&
+            parameter.name.kind === 79 /* SyntaxKind.Identifier */);
+    }
+    emitParametersForArrow(parent, parameters) {
+        if (this.canEmitSimpleArrowHead(parent, parameters)) {
+            this.generateAllNames(parameters);
+            return this.emitList(3 /* ListItem.Parameter */, parent, parameters, 528 /* ListFormat.SingleArrowParameter */);
+        }
+        return this.emitParameters(parent, parameters);
+    }
+    emitSignature(node, typeParameters, parameters, type) {
+        this.emitTypeParameters(node, typeParameters);
+        this.emitParameters(node, parameters);
+        return this.emitTypeAnnotation(type);
+    }
+    emitFunctionBody(body) {
+        this.context.addEmitFlags(body, 12 /* EmitFlags.NoSourceMap */);
+        this.generateNames(body);
+        this.write1('{');
+        this.writer.indent++;
+        const detached = this.emitDetachedCommentsBeforeStatementList(body, body.statements.pos);
+        const statementOffset = this.emitPrologueDirectives(body.statements);
+        const pos = this.writer.getWriteCount();
+        this.emitHelpers(body);
+        if (statementOffset === 0 &&
+            pos === this.writer.getWriteCount() &&
+            this.shouldEmitBlockFunctionBodyOnSingleLine(body)) {
+            this.writer.indent--;
+            this.emitListRange(15 /* ListItem.Statement */, body, body.statements, 768 /* ListFormat.SingleLineFunctionBodyStatements */, statementOffset);
+            this.writer.indent++;
+        }
+        else
+            this.emitListRange(15 /* ListItem.Statement */, body, body.statements, 1 /* ListFormat.MultiLineFunctionBodyStatements */, statementOffset);
+        this.emitDetachedCommentsAfterStatementList(body, body.statements.end, detached);
+        this.writer.indent--;
+        this.emitTokenEx(19 /* SyntaxKind.CloseBraceToken */, body.statements.end, body, 1 /* TokenEmitFlags.NoComments */);
+        return true;
+    }
+    emitFunctionBodyNode(node) {
+        if (node === undefined)
+            return this.write1(';');
+        this.space();
+        if (node instanceof Block)
+            return this.emitFunctionBody(node);
+        throw new Error('Unexpected function body ' + node.kind);
+    }
+    // Type members and class elements
+    emitPropertySignature(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.emitPropertyName(node.name);
+        this.emitOptionalToken(node.postfixToken);
+        this.emitTypeAnnotation(node.type);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitPropertyDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, true);
+        this.emitPropertyName(node.name);
+        this.emitOptionalToken(node.postfixToken);
+        this.emitTypeAnnotation(node.type);
+        let end = node.name.end;
+        if (node.type !== undefined && node.type.end > end)
+            end = node.type.end;
+        if (node.postfixToken !== undefined && node.postfixToken.end > end)
+            end = node.postfixToken.end;
+        this.emitInitializer(node.initializer, end, node);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    /** Emits a signature in its own name scope, indented if the node asks for it. */
+    emitScopedSignature(node, typeParameters, parameters, type, body, hasBody) {
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.pushNameGenerationScope(node);
+        this.emitSignature(node, typeParameters, parameters, type);
+        if (hasBody)
+            this.emitFunctionBodyNode(body);
+        else
+            this.write1(';');
+        this.popNameGenerationScope(node);
+        this.indentIf(indented, -1);
+        return true;
+    }
+    emitMethodSignature(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.emitPropertyName(node.name);
+        this.emitOptionalToken(node.postfixToken);
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, undefined, false);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitMethodDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, true);
+        this.emitOptionalToken(node.asteriskToken);
+        this.emitPropertyName(node.name);
+        this.emitOptionalToken(node.postfixToken);
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, node.body, true);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitClassStaticBlockDeclaration(node) {
+        const state = this.enterNode(node);
+        this.write1('static');
+        this.pushNameGenerationScope(node);
+        this.emitFunctionBodyNode(node.body);
+        this.popNameGenerationScope(node);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitConstructor(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('constructor');
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, node.body, true);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitAccessor(node, token, modifiers, name, typeParameters, parameters, type, body) {
+        const state = this.enterNode(node);
+        const pos = this.emitModifierList(node, modifiers, true);
+        this.emitToken(token, pos, node);
+        this.space();
+        this.emitPropertyName(name);
+        this.emitScopedSignature(node, typeParameters, parameters, type, body, true);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitGetAccessor(node) {
+        return this.emitAccessor(node, 138 /* SyntaxKind.GetKeyword */, node.modifiers, node.name, node.typeParameters, node.parameters, node.type, node.body);
+    }
+    emitSetAccessor(node) {
+        return this.emitAccessor(node, 153 /* SyntaxKind.SetKeyword */, node.modifiers, node.name, node.typeParameters, node.parameters, node.type, node.body);
+    }
+    emitCallSignature(node) {
+        const state = this.enterNode(node);
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, undefined, false);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitConstructSignature(node) {
+        const state = this.enterNode(node);
+        this.write1('new ');
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, undefined, false);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitIndexSignature(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.pushNameGenerationScope(node);
+        this.generateAllNames(node.parameters);
+        this.emitList(3 /* ListItem.Parameter */, node, node.parameters, 8848 /* ListFormat.IndexSignatureParameters */);
+        this.emitTypeAnnotation(node.type);
+        this.write1(';');
+        this.popNameGenerationScope(node);
+        this.indentIf(indented, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitClassElement(node) {
+        switch (node.kind) {
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (node instanceof PropertyDeclaration)
+                    return this.emitPropertyDeclaration(node);
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                if (node instanceof MethodDeclaration)
+                    return this.emitMethodDeclaration(node);
+                break;
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+                if (node instanceof ClassStaticBlockDeclaration)
+                    return this.emitClassStaticBlockDeclaration(node);
+                break;
+            case 177 /* SyntaxKind.Constructor */:
+                if (node instanceof ConstructorDeclaration)
+                    return this.emitConstructor(node);
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (node instanceof GetAccessorDeclaration)
+                    return this.emitGetAccessor(node);
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (node instanceof SetAccessorDeclaration)
+                    return this.emitSetAccessor(node);
+                break;
+            case 182 /* SyntaxKind.IndexSignature */:
+                if (node instanceof IndexSignatureDeclaration)
+                    return this.emitIndexSignature(node);
+                break;
+            case 241 /* SyntaxKind.SemicolonClassElement */:
+                return this.emitSimpleNode(node, ';');
+            case 347 /* SyntaxKind.NotEmittedStatement */:
+                return this.emitSimpleNode(node, '');
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                if (node instanceof TypeAliasDeclaration)
+                    return this.emitTypeAliasDeclaration(node);
+                break;
+        }
+        throw new Error('Unexpected class element ' + node.kind);
+    }
+    emitTypeElement(node) {
+        switch (node.kind) {
+            case 172 /* SyntaxKind.PropertySignature */:
+                if (node instanceof PropertySignatureDeclaration)
+                    return this.emitPropertySignature(node);
+                break;
+            case 174 /* SyntaxKind.MethodSignature */:
+                if (node instanceof MethodSignatureDeclaration)
+                    return this.emitMethodSignature(node);
+                break;
+            case 180 /* SyntaxKind.CallSignature */:
+                if (node instanceof CallSignatureDeclaration)
+                    return this.emitCallSignature(node);
+                break;
+            case 181 /* SyntaxKind.ConstructSignature */:
+                if (node instanceof ConstructSignatureDeclaration)
+                    return this.emitConstructSignature(node);
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (node instanceof GetAccessorDeclaration)
+                    return this.emitGetAccessor(node);
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (node instanceof SetAccessorDeclaration)
+                    return this.emitSetAccessor(node);
+                break;
+            case 182 /* SyntaxKind.IndexSignature */:
+                if (node instanceof IndexSignatureDeclaration)
+                    return this.emitIndexSignature(node);
+                break;
+            case 350 /* SyntaxKind.NotEmittedTypeElement */:
+                return this.emitSimpleNode(node, '');
+        }
+        throw new Error('Unexpected type element ' + node.kind);
+    }
+    emitObjectLiteralElement(node) {
+        switch (node.kind) {
+            case 303 /* SyntaxKind.PropertyAssignment */:
+                if (node instanceof PropertyAssignment)
+                    return this.emitPropertyAssignment(node);
+                break;
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                if (node instanceof ShorthandPropertyAssignment)
+                    return this.emitShorthandPropertyAssignment(node);
+                break;
+            case 305 /* SyntaxKind.SpreadAssignment */:
+                if (node instanceof SpreadAssignment)
+                    return this.emitSpreadAssignment(node);
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                if (node instanceof MethodDeclaration)
+                    return this.emitMethodDeclaration(node);
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (node instanceof GetAccessorDeclaration)
+                    return this.emitGetAccessor(node);
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (node instanceof SetAccessorDeclaration)
+                    return this.emitSetAccessor(node);
+                break;
+        }
+        throw new Error('Unexpected object literal element ' + node.kind);
+    }
+    /** A node printed as fixed text, such as `;` for a semicolon class element. */
+    emitSimpleNode(node, text) {
+        const state = this.enterNode(node);
+        if (text.length > 0)
+            this.write1(text);
+        this.exitNode(node, state);
+        return true;
+    }
+    // Types
+    emitTypePredicate(node) {
+        const state = this.enterNode(node);
+        if (node.assertsModifier !== undefined) {
+            this.emitOptionalToken(node.assertsModifier);
+            this.space();
+        }
+        const name = node.parameterName;
+        if (name instanceof Identifier)
+            this.emitIdentifierReference(name);
+        else
+            this.emitSimpleNode(name, 'this');
+        if (node.type !== undefined) {
+            this.write1(' is ');
+            this.emitTypeNodeOutsideExtends(node.type);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTypeArguments(parent, nodes) {
+        if (nodes === undefined)
+            return false;
+        return this.emitList(7 /* ListItem.TypeArgument */, parent, nodes, 53776 /* ListFormat.TypeArguments */);
+    }
+    emitReturnType(node) {
+        if (node === undefined)
+            return false;
+        this.write1('=> ');
+        if (this.inExtends && node instanceof InferTypeNode && node.typeParameter.constraint !== undefined)
+            return this.emitTypeNode(node, 7 /* TypePrecedence.Highest */);
+        return this.emitTypeNode(node, 0 /* TypePrecedence.Lowest */);
+    }
+    emitFunctionType(node) {
+        const state = this.enterNode(node);
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.pushNameGenerationScope(node);
+        this.emitTypeParameters(node, node.typeParameters);
+        this.emitParameters(node, node.parameters);
+        this.space();
+        this.emitReturnType(node.type);
+        this.popNameGenerationScope(node);
+        this.indentIf(indented, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitConstructorType(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('new ');
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.pushNameGenerationScope(node);
+        this.emitTypeParameters(node, node.typeParameters);
+        this.emitParameters(node, node.parameters);
+        this.space();
+        this.emitReturnType(node.type);
+        this.popNameGenerationScope(node);
+        this.indentIf(indented, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTypeLiteral(node) {
+        const state = this.enterNode(node);
+        this.pushNameGenerationScope(node);
+        this.generateAllMemberNames(node.members);
+        this.write1('{');
+        const format = this.shouldEmitOnSingleLine(node)
+            ? 768 /* ListFormat.SingleLineTypeLiteralMembers */
+            : 32897 /* ListFormat.MultiLineTypeLiteralMembers */;
+        this.emitList(4 /* ListItem.TypeElement */, node, node.members, format | 524288 /* ListFormat.NoSpaceIfEmpty */);
+        this.write1('}');
+        this.popNameGenerationScope(node);
+        this.exitNode(node, state);
+        return true;
+    }
+    /** The operand of a postfix type; a parsed `typeof X` operand keeps no parentheses. */
+    emitPostfixTypeOperand(operand, parent) {
+        if (isParseTreeNode(parent) && operand.kind === 187 /* SyntaxKind.TypeQuery */)
+            return this.emitTypeNode(operand, 5 /* TypePrecedence.TypeOperator */);
+        return this.emitTypeNode(operand, 6 /* TypePrecedence.Postfix */);
+    }
+    emitTupleType(node) {
+        const state = this.enterNode(node);
+        this.emitToken(22 /* SyntaxKind.OpenBracketToken */, node.pos, node);
+        const format = this.shouldEmitOnSingleLine(node)
+            ? 528 /* ListFormat.SingleLineTupleTypeElements */
+            : 657 /* ListFormat.MultiLineTupleTypeElements */;
+        this.emitList(7 /* ListItem.TypeArgument */, node, node.elements, format | 524288 /* ListFormat.NoSpaceIfEmpty */);
+        this.emitToken(23 /* SyntaxKind.CloseBracketToken */, node.elements.end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitNamedTupleMember(node) {
+        const state = this.enterNode(node);
+        this.emitOptionalToken(node.dotDotDotToken);
+        this.emitIdentifierName(node.name);
+        this.emitOptionalToken(node.questionToken);
+        let end = node.name.end;
+        if (node.questionToken !== undefined && node.questionToken.end > end)
+            end = node.questionToken.end;
+        this.emitToken(58 /* SyntaxKind.ColonToken */, end, node);
+        this.space();
+        this.emitTypeNodeOutsideExtends(node.type);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitConditionalType(node) {
+        const state = this.enterNode(node);
+        this.emitTypeNode(node.checkType, 3 /* TypePrecedence.Union */);
+        this.write1(' extends ');
+        this.emitTypeNodeInExtends(node.extendsType);
+        this.write1(' ? ');
+        this.emitTypeNodeOutsideExtends(node.trueType);
+        this.write1(' : ');
+        this.emitTypeNodeOutsideExtends(node.falseType);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitInferType(node) {
+        const state = this.enterNode(node);
+        this.write1('infer ');
+        const parameter = node.typeParameter;
+        const parameterState = this.enterNode(parameter);
+        this.emitBindingIdentifier(parameter.name);
+        if (parameter.constraint !== undefined) {
+            this.write1(' extends ');
+            this.emitTypeNodeInExtends(parameter.constraint);
+        }
+        this.exitNode(parameter, parameterState);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTypeOperator(node) {
+        const state = this.enterNode(node);
+        this.emitToken(node.operator, node.pos, node);
+        this.space();
+        this.emitTypeNode(node.type, node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ ? 6 /* TypePrecedence.Postfix */ : 5 /* TypePrecedence.TypeOperator */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitMappedType(node) {
+        const state = this.enterNode(node);
+        const singleLine = this.shouldEmitOnSingleLine(node);
+        this.write1('{');
+        if (singleLine)
+            this.space();
+        else {
+            this.line();
+            this.writer.indent++;
+        }
+        const readonlyToken = node.readonlyToken;
+        if (readonlyToken !== undefined) {
+            this.emitOptionalToken(readonlyToken);
+            if (readonlyToken.kind !== 148 /* SyntaxKind.ReadonlyKeyword */)
+                this.write1('readonly');
+            this.space();
+        }
+        this.write1('[');
+        const parameter = node.typeParameter;
+        const parameterState = this.enterNode(parameter);
+        this.emitBindingIdentifier(parameter.name);
+        this.write1(' in ');
+        this.emitTypeNodeOutsideExtends(parameter.constraint);
+        this.exitNode(parameter, parameterState);
+        if (node.nameType !== undefined) {
+            this.write1(' as ');
+            this.emitTypeNodeOutsideExtends(node.nameType);
+        }
+        this.write1(']');
+        const questionToken = node.questionToken;
+        if (questionToken !== undefined) {
+            this.emitOptionalToken(questionToken);
+            if (questionToken.kind !== 57 /* SyntaxKind.QuestionToken */)
+                this.write1('?');
+        }
+        this.write1(': ');
+        // tsgo's printer fails on a mapped type without a type, too.
+        if (node.type === undefined)
+            throw new Error('Mapped type without a type');
+        this.emitTypeNodeOutsideExtends(node.type);
+        this.write1(';');
+        if (node.members !== undefined && node.members.nodes.length > 0) {
+            if (singleLine)
+                this.space();
+            else
+                this.line();
+            this.emitList(4 /* ListItem.TypeElement */, node, node.members, 2 /* ListFormat.PreserveLines */);
+        }
+        if (singleLine)
+            this.space();
+        else {
+            this.line();
+            this.writer.indent--;
+        }
+        this.write1('}');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTemplateType(node) {
+        const state = this.enterNode(node);
+        this.emitLiteral(node.head);
+        this.emitList(9 /* ListItem.TemplateTypeSpan */, node, node.templateSpans, 262144 /* ListFormat.TemplateExpressionSpans */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTemplateTypeSpan(node) {
+        const state = this.enterNode(node);
+        this.emitTypeNodeOutsideExtends(node.type);
+        this.emitLiteral(node.literal);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitImportType(node) {
+        const state = this.enterNode(node);
+        if (node.isTypeOf)
+            this.write1('typeof ');
+        this.write1('import(');
+        this.emitTypeNodeOutsideExtends(node.argument);
+        const attributes = node.attributes;
+        if (attributes !== undefined) {
+            this.write1(', ');
+            const attributesState = this.enterNode(attributes);
+            this.write1('{ ');
+            this.write1(attributes.token === 131 /* SyntaxKind.AssertKeyword */ ? 'assert' : 'with');
+            this.write1(': ');
+            this.emitList(10 /* ListItem.ImportAttribute */, attributes, attributes.attributes, 526226 /* ListFormat.ImportAttributes */);
+            this.write1(' }');
+            this.exitNode(attributes, attributesState);
+        }
+        this.write1(')');
+        if (node.qualifier !== undefined) {
+            this.write1('.');
+            this.emitEntityName(node.qualifier);
+        }
+        this.emitTypeArguments(node, node.typeArguments);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTypeNodeInExtends(node) {
+        const saved = this.inExtends;
+        this.inExtends = true;
+        this.emitTypeNode(node, 0 /* TypePrecedence.Lowest */);
+        this.inExtends = saved;
+        return true;
+    }
+    emitTypeNodeOutsideExtends(node) {
+        const saved = this.inExtends;
+        this.inExtends = false;
+        this.emitTypeNode(node, 0 /* TypePrecedence.Lowest */);
+        this.inExtends = saved;
+        return true;
+    }
+    emitTypeNode(node, precedence) {
+        if (this.inExtends && precedence <= 0 /* TypePrecedence.Conditional */)
+            precedence = 2 /* TypePrecedence.Function */;
+        const savedInExtends = this.inExtends;
+        const parens = getTypeNodePrecedence(node) < precedence;
+        if (parens) {
+            this.inExtends = false;
+            this.write1('(');
+        }
+        this.emitTypeNodeWorker(node);
+        if (parens)
+            this.write1(')');
+        this.inExtends = savedInExtends;
+        return true;
+    }
+    emitTypeNodeWorker(node) {
+        switch (node.kind) {
+            case 132 /* SyntaxKind.AnyKeyword */:
+            case 159 /* SyntaxKind.UnknownKeyword */:
+            case 150 /* SyntaxKind.NumberKeyword */:
+            case 163 /* SyntaxKind.BigIntKeyword */:
+            case 151 /* SyntaxKind.ObjectKeyword */:
+            case 135 /* SyntaxKind.BooleanKeyword */:
+            case 154 /* SyntaxKind.StringKeyword */:
+            case 155 /* SyntaxKind.SymbolKeyword */:
+            case 115 /* SyntaxKind.VoidKeyword */:
+            case 157 /* SyntaxKind.UndefinedKeyword */:
+            case 146 /* SyntaxKind.NeverKeyword */:
+            case 141 /* SyntaxKind.IntrinsicKeyword */:
+                return this.emitTokenNode(node);
+            case 310 /* SyntaxKind.JSDocAllType */:
+                return this.emitSimpleNode(node, tokenToString(node.kind));
+            case 198 /* SyntaxKind.ThisType */:
+                return this.emitSimpleNode(node, 'this');
+            case 183 /* SyntaxKind.TypePredicate */:
+                if (node instanceof TypePredicateNode)
+                    return this.emitTypePredicate(node);
+                break;
+            case 184 /* SyntaxKind.TypeReference */:
+                if (node instanceof TypeReferenceNode) {
+                    const state = this.enterNode(node);
+                    this.emitEntityName(node.typeName);
+                    this.emitTypeArguments(node, node.typeArguments);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 185 /* SyntaxKind.FunctionType */:
+                if (node instanceof FunctionTypeNode)
+                    return this.emitFunctionType(node);
+                break;
+            case 186 /* SyntaxKind.ConstructorType */:
+                if (node instanceof ConstructorTypeNode)
+                    return this.emitConstructorType(node);
+                break;
+            case 187 /* SyntaxKind.TypeQuery */:
+                if (node instanceof TypeQueryNode) {
+                    const state = this.enterNode(node);
+                    this.write1('typeof ');
+                    this.emitEntityName(node.exprName);
+                    this.emitTypeArguments(node, node.typeArguments);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 188 /* SyntaxKind.TypeLiteral */:
+                if (node instanceof TypeLiteralNode)
+                    return this.emitTypeLiteral(node);
+                break;
+            case 189 /* SyntaxKind.ArrayType */:
+                if (node instanceof ArrayTypeNode) {
+                    const state = this.enterNode(node);
+                    this.emitPostfixTypeOperand(node.elementType, node);
+                    this.write1('[');
+                    this.write1(']');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 190 /* SyntaxKind.TupleType */:
+                if (node instanceof TupleTypeNode)
+                    return this.emitTupleType(node);
+                break;
+            case 191 /* SyntaxKind.OptionalType */:
+                if (node instanceof OptionalTypeNode) {
+                    const state = this.enterNode(node);
+                    this.emitPostfixTypeOperand(node.type, node);
+                    this.write1('?');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 192 /* SyntaxKind.RestType */:
+                if (node instanceof RestTypeNode) {
+                    const state = this.enterNode(node);
+                    this.write1('...');
+                    this.emitTypeNodeOutsideExtends(node.type);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 193 /* SyntaxKind.UnionType */:
+                if (node instanceof UnionTypeNode) {
+                    const state = this.enterNode(node);
+                    this.emitList(8 /* ListItem.UnionConstituent */, node, node.types, 516 /* ListFormat.UnionTypeConstituents */);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 194 /* SyntaxKind.IntersectionType */:
+                if (node instanceof IntersectionTypeNode) {
+                    const state = this.enterNode(node);
+                    this.emitList(8 /* ListItem.UnionConstituent */, node, node.types, 520 /* ListFormat.IntersectionTypeConstituents */);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 195 /* SyntaxKind.ConditionalType */:
+                if (node instanceof ConditionalTypeNode)
+                    return this.emitConditionalType(node);
+                break;
+            case 196 /* SyntaxKind.InferType */:
+                if (node instanceof InferTypeNode)
+                    return this.emitInferType(node);
+                break;
+            case 197 /* SyntaxKind.ParenthesizedType */:
+                if (node instanceof ParenthesizedTypeNode) {
+                    const state = this.enterNode(node);
+                    this.write1('(');
+                    this.emitTypeNodeOutsideExtends(node.type);
+                    this.write1(')');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 199 /* SyntaxKind.TypeOperator */:
+                if (node instanceof TypeOperatorNode)
+                    return this.emitTypeOperator(node);
+                break;
+            case 200 /* SyntaxKind.IndexedAccessType */:
+                if (node instanceof IndexedAccessTypeNode) {
+                    const state = this.enterNode(node);
+                    this.emitPostfixTypeOperand(node.objectType, node);
+                    this.write1('[');
+                    this.emitTypeNodeOutsideExtends(node.indexType);
+                    this.write1(']');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 201 /* SyntaxKind.MappedType */:
+                if (node instanceof MappedTypeNode)
+                    return this.emitMappedType(node);
+                break;
+            case 202 /* SyntaxKind.LiteralType */:
+                if (node instanceof LiteralTypeNode) {
+                    const state = this.enterNode(node);
+                    this.emitExpression(node.literal, 0 /* OperatorPrecedence.Comma */);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 203 /* SyntaxKind.NamedTupleMember */:
+                if (node instanceof NamedTupleMember)
+                    return this.emitNamedTupleMember(node);
+                break;
+            case 204 /* SyntaxKind.TemplateLiteralType */:
+                if (node instanceof TemplateLiteralTypeNode)
+                    return this.emitTemplateType(node);
+                break;
+            case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+                if (node instanceof TemplateLiteralTypeSpan)
+                    return this.emitTemplateTypeSpan(node);
+                break;
+            case 206 /* SyntaxKind.ImportType */:
+                if (node instanceof ImportTypeNode)
+                    return this.emitImportType(node);
+                break;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                if (node instanceof PropertyAccessExpression)
+                    return this.emitPropertyAccessExpression(node);
+                break;
+            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+                if (node instanceof ExpressionWithTypeArguments)
+                    return this.emitExpressionWithTypeArguments(node);
+                break;
+            case 312 /* SyntaxKind.JSDocNonNullableType */:
+                if (node instanceof JSDocNonNullableType)
+                    return this.emitJSDocPrefixType(node, '!', node.type);
+                break;
+            case 311 /* SyntaxKind.JSDocNullableType */:
+                if (node instanceof JSDocNullableType)
+                    return this.emitJSDocPrefixType(node, '?', node.type);
+                break;
+            case 313 /* SyntaxKind.JSDocOptionalType */:
+                if (node instanceof JSDocOptionalType) {
+                    const state = this.enterNode(node);
+                    this.emitTypeNode(node.type, 1 /* TypePrecedence.JSDoc */);
+                    this.write1('=');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 314 /* SyntaxKind.JSDocVariadicType */:
+                if (node instanceof JSDocVariadicType) {
+                    const state = this.enterNode(node);
+                    this.write1('...');
+                    this.emitTypeNode(node.type, 1 /* TypePrecedence.JSDoc */);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+        }
+        throw new Error('Unexpected type node ' + node.kind);
+    }
+    emitJSDocPrefixType(node, prefix, type) {
+        const state = this.enterNode(node);
+        this.write1(prefix);
+        this.emitTypeNode(type, 7 /* TypePrecedence.NonArray */);
+        this.exitNode(node, state);
+        return true;
+    }
+    // Binding patterns
+    emitBindingPattern(node) {
+        const state = this.enterNode(node);
+        const object = node.kind === 207 /* SyntaxKind.ObjectBindingPattern */;
+        this.write1(object ? '{' : '[');
+        this.emitList(11 /* ListItem.BindingElement */, node, node.elements, object ? 525136 /* ListFormat.ObjectBindingPatternElements */ : 524880 /* ListFormat.ArrayBindingPatternElements */);
+        this.write1(object ? '}' : ']');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitBindingElement(node) {
+        const state = this.enterNode(node);
+        this.emitOptionalToken(node.dotDotDotToken);
+        if (node.propertyName !== undefined) {
+            this.emitPropertyName(node.propertyName);
+            this.write1(': ');
+        }
+        const name = node.name;
+        if (name !== undefined) {
+            this.emitBindingName(name);
+            this.emitInitializer(node.initializer, name.end, node);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    // Expressions
+    emitArrayLiteralExpression(node) {
+        const state = this.enterNode(node);
+        this.emitList(12 /* ListItem.ArrayElement */, node, node.elements, 8914 /* ListFormat.ArrayLiteralExpressionElements */ | (node.multiLine ? 65536 /* ListFormat.PreferNewLine */ : 0));
+        this.exitNode(node, state);
+        return true;
+    }
+    emitObjectLiteralExpression(node) {
+        const state = this.enterNode(node);
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.pushNameGenerationScope(node);
+        this.generateAllMemberNames(node.properties);
+        this.emitList(6 /* ListItem.ObjectLiteralElement */, node, node.properties, 526226 /* ListFormat.ObjectLiteralExpressionProperties */ |
+            (node.multiLine ? 65536 /* ListFormat.PreferNewLine */ : 0) |
+            (this.shouldAllowTrailingComma(node) ? 64 /* ListFormat.AllowTrailingComma */ : 0));
+        this.popNameGenerationScope(node);
+        this.indentIf(indented, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    /** `1..toString()`: a decimal integer literal needs a second dot before a property access. */
+    mayNeedDotDotForPropertyAccess(expression) {
+        expression = skipPartiallyEmittedExpressions(expression);
+        if (!(expression instanceof NumericLiteral))
+            return false;
+        const text = this.getLiteralTextOfNode(expression, undefined, 1 /* LiteralTextFlags.NeverAsciiEscape */);
+        return ((expression.tokenFlags & 448 /* TokenFlags.WithSpecifier */) === 0 &&
+            text.indexOf('.') < 0 &&
+            text.indexOf('E') < 0 &&
+            text.indexOf('e') < 0);
+    }
+    emitPropertyAccessExpression(node) {
+        const state = this.enterNode(node);
+        this.emitExpression(node.expression, isOptionalChain(node) ? 19 /* OperatorPrecedence.OptionalChain */ : 20 /* OperatorPrecedence.Member */);
+        let token = node.questionDotToken;
+        if (token === undefined) {
+            const dot = this.context.factory.createToken(24 /* SyntaxKind.DotToken */);
+            dot.pos = node.expression.end;
+            dot.end = node.name.pos;
+            this.context.addEmitFlags(dot, 12 /* EmitFlags.NoSourceMap */);
+            token = dot;
+        }
+        const linesBeforeDot = this.getLinesBetweenNodes(node, node.expression, token);
+        this.lines(linesBeforeDot);
+        this.indentIf(linesBeforeDot > 0, 1);
+        if (token.kind !== 28 /* SyntaxKind.QuestionDotToken */ &&
+            this.mayNeedDotDotForPropertyAccess(node.expression) &&
+            !this.writer.hasTrailingComment() &&
+            !this.writer.hasTrailingWhitespace())
+            this.write1('.');
+        if (node.questionDotToken !== undefined)
+            this.emitTokenNode(token);
+        else
+            this.emitToken(24 /* SyntaxKind.DotToken */, node.expression.end, node);
+        const linesAfterDot = this.getLinesBetweenNodes(node, token, node.name);
+        this.lines(linesAfterDot);
+        this.indentIf(linesAfterDot > 0, 1);
+        this.emitMemberName(node.name);
+        this.indentIf(linesAfterDot > 0, -1);
+        this.indentIf(linesBeforeDot > 0, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitElementAccessExpression(node) {
+        const state = this.enterNode(node);
+        this.emitExpression(node.expression, isOptionalChain(node) ? 19 /* OperatorPrecedence.OptionalChain */ : 20 /* OperatorPrecedence.Member */);
+        this.emitOptionalToken(node.questionDotToken);
+        let pos = node.expression.end;
+        if (node.questionDotToken !== undefined && node.questionDotToken.end > pos)
+            pos = node.questionDotToken.end;
+        this.emitToken(22 /* SyntaxKind.OpenBracketToken */, pos, node);
+        this.emitExpression(node.argumentExpression, 0 /* OperatorPrecedence.Comma */);
+        this.emitToken(23 /* SyntaxKind.CloseBracketToken */, node.argumentExpression.end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitCallee(callee, parent) {
+        if (this.hasEmitFlag(parent, 1048576 /* EmitFlags.IndirectCall */)) {
+            this.write1('(');
+            this.write1('0');
+            this.write1(', ');
+            this.emitExpression(callee, 0 /* OperatorPrecedence.Comma */);
+            return this.write1(')');
+        }
+        if (parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+            isNewExpressionWithoutArguments(skipPartiallyEmittedExpressions(callee)))
+            return this.emitExpression(callee, 22 /* OperatorPrecedence.Parentheses */);
+        return this.emitExpression(callee, isOptionalChain(parent) ? 19 /* OperatorPrecedence.OptionalChain */ : 20 /* OperatorPrecedence.Member */);
+    }
+    emitCallExpression(node) {
+        const state = this.enterNode(node);
+        this.emitCallee(node.expression, node);
+        this.emitOptionalToken(node.questionDotToken);
+        this.emitTypeArguments(node, node.typeArguments);
+        this.emitList(13 /* ListItem.Argument */, node, node.arguments, 2576 /* ListFormat.CallExpressionArguments */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitNewExpression(node) {
+        const state = this.enterNode(node);
+        this.emitToken(104 /* SyntaxKind.NewKeyword */, node.pos, node);
+        this.space();
+        if (skipPartiallyEmittedExpressions(node.expression).kind === 214 /* SyntaxKind.CallExpression */)
+            this.emitExpression(node.expression, 22 /* OperatorPrecedence.Parentheses */);
+        else
+            this.emitExpression(node.expression, 20 /* OperatorPrecedence.Member */);
+        this.emitTypeArguments(node, node.typeArguments);
+        this.emitList(13 /* ListItem.Argument */, node, node.arguments, 18960 /* ListFormat.NewExpressionArguments */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTaggedTemplateExpression(node) {
+        const state = this.enterNode(node);
+        this.emitCallee(node.tag, node);
+        this.emitTypeArguments(node, node.typeArguments);
+        this.space();
+        const template = node.template;
+        if (template instanceof TemplateExpression)
+            this.emitTemplateExpression(template);
+        else
+            this.emitLiteral(template);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitParenthesizedExpression(node) {
+        const state = this.enterNode(node);
+        this.emitToken(20 /* SyntaxKind.OpenParenToken */, node.pos, node);
+        const indented = this.writeLineSeparatorsAndIndentBefore(node.expression, node);
+        this.emitExpression(node.expression, 0 /* OperatorPrecedence.Comma */);
+        this.writeLineSeparatorsAfter(node.expression, node);
+        this.indentIf(indented, -1);
+        this.emitToken(21 /* SyntaxKind.CloseParenToken */, node.expression.end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitFunctionExpression(node) {
+        const state = this.enterNode(node);
+        this.generateNameIfNeeded(node.name);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('function');
+        this.emitOptionalToken(node.asteriskToken);
+        this.space();
+        if (node.name !== undefined)
+            this.emitIdentifierName(node.name);
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, node.body, true);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitConciseBody(node) {
+        if (node instanceof Block)
+            return this.emitFunctionBody(node);
+        if (getLeftmostExpression(node, false).kind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+            const paren = this.context.factory.createParenthesizedExpression(node);
+            paren.pos = node.pos;
+            paren.end = node.end;
+            return this.emitExpression(paren, 0 /* OperatorPrecedence.Lowest */);
+        }
+        if (isExpression(node))
+            return this.emitExpression(node, 2 /* OperatorPrecedence.Yield */);
+        throw new Error('Unexpected concise body ' + node.kind);
+    }
+    emitArrowFunction(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.pushNameGenerationScope(node);
+        this.emitTypeParameters(node, node.typeParameters);
+        this.emitParametersForArrow(node, node.parameters);
+        this.emitTypeAnnotation(node.type);
+        this.space();
+        this.emitOptionalToken(node.equalsGreaterThanToken);
+        this.space();
+        this.emitConciseBody(node.body);
+        this.popNameGenerationScope(node);
+        this.indentIf(indented, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    /** `delete`, `typeof`, `void` and `await` expressions. */
+    emitKeywordUnary(node, keyword, operand) {
+        const state = this.enterNode(node);
+        this.emitToken(keyword, node.pos, node);
+        this.space();
+        this.emitExpression(operand, 16 /* OperatorPrecedence.Unary */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitPrefixUnaryExpression(node) {
+        const state = this.enterNode(node);
+        const operator = node.operator;
+        const operand = node.operand;
+        this.emitToken(operator, node.pos, node);
+        if (operand instanceof PrefixUnaryExpression) {
+            const inner = operand.operator;
+            if ((operator === 39 /* SyntaxKind.PlusToken */ && (inner === 39 /* SyntaxKind.PlusToken */ || inner === 45 /* SyntaxKind.PlusPlusToken */)) ||
+                (operator === 40 /* SyntaxKind.MinusToken */ &&
+                    (inner === 40 /* SyntaxKind.MinusToken */ || inner === 46 /* SyntaxKind.MinusMinusToken */)))
+                this.space();
+        }
+        this.emitExpression(operand, 16 /* OperatorPrecedence.Unary */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitPostfixUnaryExpression(node) {
+        const state = this.enterNode(node);
+        this.emitExpression(node.operand, 18 /* OperatorPrecedence.LeftHandSide */);
+        this.emitToken(node.operator, node.operand.end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    /** The literal kind shared by all operands of a chain of `+`, or Unknown. */
+    getLiteralKindOfBinaryPlusOperand(node) {
+        node = skipPartiallyEmittedExpressions(node);
+        if (isLiteralKind(node.kind))
+            return node.kind;
+        if (node instanceof BinaryExpression && node.operatorToken.kind === 39 /* SyntaxKind.PlusToken */) {
+            const left = this.getLiteralKindOfBinaryPlusOperand(node.left);
+            if (isLiteralKind(left) && left === this.getLiteralKindOfBinaryPlusOperand(node.right))
+                return left;
+        }
+        return 0 /* SyntaxKind.Unknown */;
+    }
+    /** The precedence the right operand of a binary expression needs; the left's is `getExpressionPrecedence`. */
+    getBinaryRightPrecedence(node, precedence) {
+        switch (precedence) {
+            case 3 /* OperatorPrecedence.Assignment */:
+                return 2 /* OperatorPrecedence.Yield */;
+            case 5 /* OperatorPrecedence.LogicalOR */:
+                return 6 /* OperatorPrecedence.LogicalAND */;
+            case 6 /* OperatorPrecedence.LogicalAND */:
+                return 7 /* OperatorPrecedence.BitwiseOR */;
+            case 10 /* OperatorPrecedence.Equality */:
+                return 11 /* OperatorPrecedence.Relational */;
+            case 11 /* OperatorPrecedence.Relational */:
+                return 12 /* OperatorPrecedence.Shift */;
+            case 12 /* OperatorPrecedence.Shift */:
+                return 13 /* OperatorPrecedence.Additive */;
+            case 13 /* OperatorPrecedence.Additive */:
+                if (node.operatorToken.kind === 39 /* SyntaxKind.PlusToken */ && isBinaryOperation(node.right, 39 /* SyntaxKind.PlusToken */)) {
+                    const left = this.getLiteralKindOfBinaryPlusOperand(node.left);
+                    if (isLiteralKind(left) && left === this.getLiteralKindOfBinaryPlusOperand(node.right))
+                        return precedence;
+                }
+                return 14 /* OperatorPrecedence.Multiplicative */;
+            case 14 /* OperatorPrecedence.Multiplicative */:
+                if (node.operatorToken.kind === 41 /* SyntaxKind.AsteriskToken */ &&
+                    isBinaryOperation(node.right, 41 /* SyntaxKind.AsteriskToken */))
+                    return precedence;
+                return 15 /* OperatorPrecedence.Exponentiation */;
+        }
+        return precedence;
+    }
+    emitBinaryExpression(node) {
+        const precedence = getExpressionPrecedence(node);
+        let leftPrec = precedence;
+        if (precedence === 3 /* OperatorPrecedence.Assignment */)
+            leftPrec = 4 /* OperatorPrecedence.Conditional */;
+        else if (precedence === 15 /* OperatorPrecedence.Exponentiation */)
+            leftPrec = 17 /* OperatorPrecedence.Update */;
+        let rightPrec = this.getBinaryRightPrecedence(node, precedence);
+        const operator = node.operatorToken.kind;
+        const left = skipPartiallyEmittedExpressions(node.left);
+        if (nodeIsSynthesized(left) &&
+            left instanceof BinaryExpression &&
+            mixingBinaryOperatorsRequiresParentheses(operator, left.operatorToken.kind))
+            leftPrec = 22 /* OperatorPrecedence.Highest */;
+        const right = skipPartiallyEmittedExpressions(node.right);
+        if (nodeIsSynthesized(right) &&
+            right instanceof BinaryExpression &&
+            mixingBinaryOperatorsRequiresParentheses(operator, right.operatorToken.kind))
+            rightPrec = 22 /* OperatorPrecedence.Highest */;
+        const state = this.enterNode(node);
+        this.emitExpression(node.left, leftPrec);
+        const linesBefore = this.getLinesBetweenNodes(node, node.left, node.operatorToken);
+        const linesAfter = this.getLinesBetweenNodes(node, node.operatorToken, node.right);
+        this.writeLinesAndIndent(linesBefore, operator !== 27 /* SyntaxKind.CommaToken */);
+        this.emitTokenNodeEx(node.operatorToken, 4 /* TokenEmitFlags.NoSourceMaps */);
+        this.writeLinesAndIndent(linesAfter, true);
+        this.emitExpression(node.right, rightPrec);
+        this.indentIf(linesAfter > 0, -1);
+        this.indentIf(linesBefore > 0, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitConditionalExpression(node) {
+        const state = this.enterNode(node);
+        const linesBeforeQuestion = this.getLinesBetweenNodes(node, node.condition, node.questionToken);
+        const linesAfterQuestion = this.getLinesBetweenNodes(node, node.questionToken, node.whenTrue);
+        const linesBeforeColon = this.getLinesBetweenNodes(node, node.whenTrue, node.colonToken);
+        const linesAfterColon = this.getLinesBetweenNodes(node, node.colonToken, node.whenFalse);
+        this.emitExpression(node.condition, isBinaryOperation(skipPartiallyEmittedExpressions(node.condition), 60 /* SyntaxKind.QuestionQuestionToken */)
+            ? 5 /* OperatorPrecedence.Coalesce */
+            : 5 /* OperatorPrecedence.LogicalOR */);
+        this.writeLinesAndIndent(linesBeforeQuestion, true);
+        this.emitOptionalToken(node.questionToken);
+        this.writeLinesAndIndent(linesAfterQuestion, true);
+        this.emitExpression(node.whenTrue, 2 /* OperatorPrecedence.Yield */);
+        this.indentIf(linesAfterQuestion > 0, -1);
+        this.indentIf(linesBeforeQuestion > 0, -1);
+        this.writeLinesAndIndent(linesBeforeColon, true);
+        this.emitOptionalToken(node.colonToken);
+        this.writeLinesAndIndent(linesAfterColon, true);
+        this.emitExpression(node.whenFalse, 2 /* OperatorPrecedence.Yield */);
+        this.indentIf(linesAfterColon > 0, -1);
+        this.indentIf(linesBeforeColon > 0, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTemplateExpression(node) {
+        const state = this.enterNode(node);
+        this.emitLiteral(node.head);
+        this.emitList(14 /* ListItem.TemplateSpan */, node, node.templateSpans, 262144 /* ListFormat.TemplateExpressionSpans */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitYieldExpression(node) {
+        const state = this.enterNode(node);
+        this.emitToken(126 /* SyntaxKind.YieldKeyword */, node.pos, node);
+        this.emitOptionalToken(node.asteriskToken);
+        if (node.expression !== undefined) {
+            this.space();
+            this.emitExpressionNoASI(node.expression, 2 /* OperatorPrecedence.DisallowComma */);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitSpreadElement(node) {
+        const state = this.enterNode(node);
+        this.emitToken(25 /* SyntaxKind.DotDotDotToken */, node.pos, node);
+        this.emitExpression(node.expression, 2 /* OperatorPrecedence.DisallowComma */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitClassLike(node, modifiers, name, typeParameters, heritageClauses, members) {
+        const state = this.enterNode(node);
+        this.generateNameIfNeeded(name);
+        const pos = this.emitModifierList(node, modifiers, true);
+        this.emitToken(85 /* SyntaxKind.ClassKeyword */, pos, node);
+        if (name !== undefined) {
+            this.space();
+            this.emitIdentifierName(name);
+        }
+        const indented = this.indentIf(this.shouldEmitIndented(node), 1);
+        this.emitTypeParameters(node, typeParameters);
+        this.emitList(17 /* ListItem.HeritageClause */, node, heritageClauses, 0 /* ListFormat.ClassHeritageClauses */);
+        this.write1(' {');
+        this.pushNameGenerationScope(node);
+        this.generateAllMemberNames(members);
+        this.emitList(5 /* ListItem.ClassElement */, node, members, 129 /* ListFormat.ClassMembers */);
+        this.popNameGenerationScope(node);
+        this.write1('}');
+        this.indentIf(indented, -1);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitExpressionWithTypeArguments(node) {
+        const state = this.enterNode(node);
+        this.emitExpression(node.expression, 20 /* OperatorPrecedence.Member */);
+        this.emitTypeArguments(node, node.typeArguments);
+        this.exitNode(node, state);
+        return true;
+    }
+    /** `as` and `satisfies` expressions. */
+    emitTypeRelation(node, expression, keyword, type) {
+        const state = this.enterNode(node);
+        this.emitExpression(expression, 11 /* OperatorPrecedence.Relational */);
+        this.space();
+        this.write1(keyword);
+        this.space();
+        this.emitTypeNodeOutsideExtends(type);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitPartiallyEmittedExpression(node) {
+        // Nested partially emitted expressions share one pass so their parentheses aren't repeated.
+        const nodes = [];
+        const states = [];
+        for (;;) {
+            const state = this.enterNode(node);
+            if (!this.hasEmitFlag(node, 128 /* EmitFlags.NoLeadingComments */) && node.pos !== node.expression.pos)
+                this.emitTrailingCommentsOfPosition(node.expression.pos, false, false);
+            nodes.push(node);
+            states.push(state);
+            const inner = node.expression;
+            if (!(inner instanceof PartiallyEmittedExpression))
+                break;
+            node = inner;
+        }
+        this.emitExpression(node.expression, 0 /* OperatorPrecedence.Lowest */);
+        for (let i = nodes.length - 1; i >= 0; i--) {
+            if (!this.hasEmitFlag(node, 256 /* EmitFlags.NoTrailingComments */) && node.end !== node.expression.end)
+                this.emitLeadingCommentsOfPosition(node.expression.end);
+            this.exitNode(node, states[i]);
+            node = nodes[i];
+        }
+        return true;
+    }
+    commentWillEmitNewLine(comment) {
+        return comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ || comment.hasTrailingNewLine;
+    }
+    willEmitLeadingNewLine(node) {
+        if (this.currentSourceFile === undefined)
+            return false;
+        const comments = getLeadingCommentRanges(this.sourceText, node.pos);
+        let hasNewLineComment = false;
+        if (comments !== undefined) {
+            for (const comment of comments)
+                if (this.commentWillEmitNewLine(comment))
+                    hasNewLineComment = true;
+            const parseNode = this.context.parseNode(node);
+            if (parseNode !== undefined &&
+                parseNode.parent !== undefined &&
+                parseNode.parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+                return true;
+        }
+        if (hasNewLineComment)
+            return true;
+        const synthesized = this.context.getSyntheticLeadingComments(node);
+        if (synthesized !== undefined)
+            for (let i = 0; i < synthesized.length; i++)
+                if (synthesized[i].kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ || synthesized[i].hasTrailingNewLine)
+                    return true;
+        if (node instanceof PartiallyEmittedExpression) {
+            if (node.pos !== node.expression.pos) {
+                const trailing = getTrailingCommentRanges(this.sourceText, node.expression.pos);
+                if (trailing !== undefined)
+                    for (const comment of trailing)
+                        if (this.commentWillEmitNewLine(comment))
+                            return true;
+            }
+            return this.willEmitLeadingNewLine(node.expression);
+        }
+        return false;
+    }
+    /** Parenthesizes an expression whose leading comments would put a line break after `return` or `throw`. */
+    parenthesizeExpressionForNoAsi(node) {
+        if (this.commentsDisabled)
+            return node;
+        const factory = this.context.factory;
+        if (node instanceof PartiallyEmittedExpression) {
+            if (this.willEmitLeadingNewLine(node)) {
+                const parseNode = this.context.parseNode(node);
+                if (parseNode instanceof ParenthesizedExpression) {
+                    const parens = factory.createParenthesizedExpression(node.expression);
+                    this.context.setOriginal(parens, node);
+                    parens.pos = parseNode.pos;
+                    parens.end = parseNode.end;
+                    return parens;
+                }
+                return factory.createParenthesizedExpression(node);
+            }
+            return factory.updatePartiallyEmittedExpression(node, this.parenthesizeExpressionForNoAsi(node.expression));
+        }
+        if (node instanceof PropertyAccessExpression)
+            return factory.updatePropertyAccessExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.name, node.flags);
+        if (node instanceof ElementAccessExpression)
+            return factory.updateElementAccessExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.argumentExpression, node.flags);
+        if (node instanceof CallExpression)
+            return factory.updateCallExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.typeArguments, node.arguments, node.flags);
+        if (node instanceof TaggedTemplateExpression)
+            return factory.updateTaggedTemplateExpression(node, this.parenthesizeExpressionForNoAsi(node.tag), node.questionDotToken, node.typeArguments, node.template, node.flags);
+        if (node instanceof PostfixUnaryExpression)
+            return factory.updatePostfixUnaryExpression(node, this.parenthesizeExpressionForNoAsi(node.operand), node.operator);
+        if (node instanceof BinaryExpression)
+            return factory.updateBinaryExpression(node, node.modifiers, this.parenthesizeExpressionForNoAsi(node.left), node.type, node.operatorToken, node.right);
+        if (node instanceof ConditionalExpression)
+            return factory.updateConditionalExpression(node, this.parenthesizeExpressionForNoAsi(node.condition), node.questionToken, node.whenTrue, node.colonToken, node.whenFalse);
+        if (node instanceof AsExpression)
+            return factory.updateAsExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.type);
+        if (node instanceof SatisfiesExpression)
+            return factory.updateSatisfiesExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.type);
+        if (node instanceof NonNullExpression)
+            return factory.updateNonNullExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.flags);
+        return node;
+    }
+    emitExpressionNoASI(node, precedence) {
+        return this.emitExpression(this.parenthesizeExpressionForNoAsi(node), precedence);
+    }
+    emitExpression(node, precedence) {
+        const parens = getExpressionPrecedence(skipPartiallyEmittedExpressions(node)) < precedence;
+        if (parens)
+            this.write1('(');
+        this.emitExpressionWorker(node);
+        if (parens)
+            this.write1(')');
+        return true;
+    }
+    emitExpressionWorker(node) {
+        switch (node.kind) {
+            case 111 /* SyntaxKind.TrueKeyword */:
+            case 96 /* SyntaxKind.FalseKeyword */:
+            case 105 /* SyntaxKind.NullKeyword */:
+            case 109 /* SyntaxKind.ThisKeyword */:
+            case 107 /* SyntaxKind.SuperKeyword */:
+            case 101 /* SyntaxKind.ImportKeyword */:
+                return this.emitTokenNode(node);
+            case 8 /* SyntaxKind.NumericLiteral */:
+            case 9 /* SyntaxKind.BigIntLiteral */:
+            case 10 /* SyntaxKind.StringLiteral */:
+            case 13 /* SyntaxKind.RegularExpressionLiteral */:
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                return this.emitLiteral(node);
+            case 79 /* SyntaxKind.Identifier */:
+                if (node instanceof Identifier)
+                    return this.emitIdentifierReference(node);
+                break;
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+                if (node instanceof PrivateIdentifier)
+                    return this.emitPrivateIdentifier(node);
+                break;
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+                if (node instanceof ArrayLiteralExpression)
+                    return this.emitArrayLiteralExpression(node);
+                break;
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+                if (node instanceof ObjectLiteralExpression)
+                    return this.emitObjectLiteralExpression(node);
+                break;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                if (node instanceof PropertyAccessExpression)
+                    return this.emitPropertyAccessExpression(node);
+                break;
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                if (node instanceof ElementAccessExpression)
+                    return this.emitElementAccessExpression(node);
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+                if (node instanceof CallExpression)
+                    return this.emitCallExpression(node);
+                break;
+            case 215 /* SyntaxKind.NewExpression */:
+                if (node instanceof NewExpression)
+                    return this.emitNewExpression(node);
+                break;
+            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+                if (node instanceof TaggedTemplateExpression)
+                    return this.emitTaggedTemplateExpression(node);
+                break;
+            case 217 /* SyntaxKind.TypeAssertionExpression */:
+                if (node instanceof TypeAssertion) {
+                    const state = this.enterNode(node);
+                    this.write1('<');
+                    this.emitTypeNodeOutsideExtends(node.type);
+                    this.write1('>');
+                    this.emitExpression(node.expression, 17 /* OperatorPrecedence.Update */);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                if (node instanceof ParenthesizedExpression)
+                    return this.emitParenthesizedExpression(node);
+                break;
+            case 219 /* SyntaxKind.FunctionExpression */:
+                if (node instanceof FunctionExpression)
+                    return this.emitFunctionExpression(node);
+                break;
+            case 220 /* SyntaxKind.ArrowFunction */:
+                if (node instanceof ArrowFunction)
+                    return this.emitArrowFunction(node);
+                break;
+            case 221 /* SyntaxKind.DeleteExpression */:
+                if (node instanceof DeleteExpression)
+                    return this.emitKeywordUnary(node, 90 /* SyntaxKind.DeleteKeyword */, node.expression);
+                break;
+            case 222 /* SyntaxKind.TypeOfExpression */:
+                if (node instanceof TypeOfExpression)
+                    return this.emitKeywordUnary(node, 113 /* SyntaxKind.TypeOfKeyword */, node.expression);
+                break;
+            case 223 /* SyntaxKind.VoidExpression */:
+                if (node instanceof VoidExpression)
+                    return this.emitKeywordUnary(node, 115 /* SyntaxKind.VoidKeyword */, node.expression);
+                break;
+            case 224 /* SyntaxKind.AwaitExpression */:
+                if (node instanceof AwaitExpression)
+                    return this.emitKeywordUnary(node, 134 /* SyntaxKind.AwaitKeyword */, node.expression);
+                break;
+            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+                if (node instanceof PrefixUnaryExpression)
+                    return this.emitPrefixUnaryExpression(node);
+                break;
+            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+                if (node instanceof PostfixUnaryExpression)
+                    return this.emitPostfixUnaryExpression(node);
+                break;
+            case 227 /* SyntaxKind.BinaryExpression */:
+                if (node instanceof BinaryExpression)
+                    return this.emitBinaryExpression(node);
+                break;
+            case 228 /* SyntaxKind.ConditionalExpression */:
+                if (node instanceof ConditionalExpression)
+                    return this.emitConditionalExpression(node);
+                break;
+            case 229 /* SyntaxKind.TemplateExpression */:
+                if (node instanceof TemplateExpression)
+                    return this.emitTemplateExpression(node);
+                break;
+            case 230 /* SyntaxKind.YieldExpression */:
+                if (node instanceof YieldExpression)
+                    return this.emitYieldExpression(node);
+                break;
+            case 231 /* SyntaxKind.SpreadElement */:
+                if (node instanceof SpreadElement)
+                    return this.emitSpreadElement(node);
+                break;
+            case 232 /* SyntaxKind.ClassExpression */:
+                if (node instanceof ClassExpression)
+                    return this.emitClassLike(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                break;
+            case 233 /* SyntaxKind.OmittedExpression */:
+                return this.emitSimpleNode(node, '');
+            case 235 /* SyntaxKind.AsExpression */:
+                if (node instanceof AsExpression)
+                    return this.emitTypeRelation(node, node.expression, 'as', node.type);
+                break;
+            case 239 /* SyntaxKind.SatisfiesExpression */:
+                if (node instanceof SatisfiesExpression)
+                    return this.emitTypeRelation(node, node.expression, 'satisfies', node.type);
+                break;
+            case 236 /* SyntaxKind.NonNullExpression */:
+                if (node instanceof NonNullExpression) {
+                    const state = this.enterNode(node);
+                    this.emitExpression(node.expression, 20 /* OperatorPrecedence.Member */);
+                    this.write1('!');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+                if (node instanceof ExpressionWithTypeArguments)
+                    return this.emitExpressionWithTypeArguments(node);
+                break;
+            case 237 /* SyntaxKind.MetaProperty */:
+                if (node instanceof MetaProperty) {
+                    const state = this.enterNode(node);
+                    this.emitToken(node.keywordToken, node.pos, node);
+                    this.write1('.');
+                    this.emitIdentifierName(node.name);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 283 /* SyntaxKind.MissingDeclaration */:
+            case 347 /* SyntaxKind.NotEmittedStatement */:
+                return false;
+            case 285 /* SyntaxKind.JsxElement */:
+                if (node instanceof JsxElement)
+                    return this.emitJsxElement(node);
+                break;
+            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+                if (node instanceof JsxSelfClosingElement)
+                    return this.emitJsxSelfClosingElement(node);
+                break;
+            case 289 /* SyntaxKind.JsxFragment */:
+                if (node instanceof JsxFragment)
+                    return this.emitJsxFragment(node);
+                break;
+            case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+                if (node instanceof PartiallyEmittedExpression)
+                    return this.emitPartiallyEmittedExpression(node);
+                break;
+        }
+        throw new Error('Unexpected expression ' + node.kind);
+    }
+    // Statements
+    isEmptyBlock(block, statements) {
+        return (statements.nodes.length === 0 &&
+            (this.currentSourceFile === undefined || this.rangeEndIsOnSameLineAsRangeStart(block.end, block.pos)));
+    }
+    emitBlock(node) {
+        const state = this.enterNode(node);
+        this.generateNames(node);
+        this.emitToken(18 /* SyntaxKind.OpenBraceToken */, node.pos, node);
+        const format = (!node.multiLine && this.isEmptyBlock(node, node.statements)) || this.shouldEmitOnSingleLine(node)
+            ? 768 /* ListFormat.SingleLineBlockStatements */
+            : 129 /* ListFormat.MultiLineBlockStatements */;
+        this.emitList(15 /* ListItem.Statement */, node, node.statements, format);
+        this.emitTokenEx(19 /* SyntaxKind.CloseBraceToken */, node.statements.end, node, (format & 1 /* ListFormat.MultiLine */) !== 0 ? 2 /* TokenEmitFlags.IndentLeadingComments */ : 0 /* TokenEmitFlags.None */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitVariableStatement(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.emitVariableDeclarationList(node.declarationList);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitExpressionStatement(node) {
+        const state = this.enterNode(node);
+        const json = this.currentSourceFile !== undefined && this.currentSourceFile.scriptKind === 6 /* ScriptKind.JSON */;
+        const expression = node.expression;
+        if (json)
+            this.emitExpression(expression, 0 /* OperatorPrecedence.Comma */);
+        else if (isImmediatelyInvokedFunctionExpressionOrArrowFunction(expression)) {
+            // Parenthesize only the callee: `(function () {})()`.
+            const call = skipPartiallyEmittedExpressions(expression);
+            if (call instanceof CallExpression) {
+                const callState = this.enterNode(call);
+                this.write1('(');
+                this.emitExpression(call.expression, 0 /* OperatorPrecedence.Lowest */);
+                this.write1(')');
+                this.emitOptionalToken(call.questionDotToken);
+                this.emitTypeArguments(call, call.typeArguments);
+                this.emitList(13 /* ListItem.Argument */, call, call.arguments, 2576 /* ListFormat.CallExpressionArguments */);
+                this.exitNode(call, callState);
+            }
+        }
+        else {
+            const leftmost = getLeftmostExpression(expression, false).kind;
+            this.emitExpression(expression, leftmost === 219 /* SyntaxKind.FunctionExpression */ || leftmost === 211 /* SyntaxKind.ObjectLiteralExpression */
+                ? 22 /* OperatorPrecedence.Parentheses */
+                : 0 /* OperatorPrecedence.Comma */);
+        }
+        if (!json || nodeIsSynthesized(expression))
+            this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    /** `if`/`while`/`with`/`switch` heads: keyword, `(`, expression, `)`. */
+    emitKeywordAndParenthesizedExpression(node, keyword, keywordPos, expression) {
+        const pos = this.emitToken(keyword, keywordPos, node);
+        this.space();
+        this.emitToken(20 /* SyntaxKind.OpenParenToken */, pos, node);
+        this.emitExpression(expression, 0 /* OperatorPrecedence.Lowest */);
+        this.emitToken(21 /* SyntaxKind.CloseParenToken */, expression.end, node);
+        return true;
+    }
+    emitIfStatement(node) {
+        const state = this.enterNode(node);
+        this.emitKeywordAndParenthesizedExpression(node, 100 /* SyntaxKind.IfKeyword */, node.pos, node.expression);
+        this.emitEmbeddedStatement(node, node.thenStatement);
+        const elseStatement = node.elseStatement;
+        if (elseStatement !== undefined) {
+            this.writeLineOrSpace(node, node.thenStatement, elseStatement);
+            this.emitToken(92 /* SyntaxKind.ElseKeyword */, node.thenStatement.end, node);
+            if (elseStatement instanceof IfStatement) {
+                this.space();
+                this.emitIfStatement(elseStatement);
+            }
+            else
+                this.emitEmbeddedStatement(node, elseStatement);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitDoStatement(node) {
+        const state = this.enterNode(node);
+        this.emitToken(91 /* SyntaxKind.DoKeyword */, node.pos, node);
+        this.emitEmbeddedStatement(node, node.statement);
+        if (node.statement instanceof Block && !this.options.preserveSourceNewlines)
+            this.space();
+        else
+            this.writeLineOrSpace(node, node.statement, node.expression);
+        this.emitKeywordAndParenthesizedExpression(node, 116 /* SyntaxKind.WhileKeyword */, node.statement.end, node.expression);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitForInitializer(node) {
+        if (node instanceof VariableDeclarationList)
+            return this.emitVariableDeclarationList(node);
+        return this.emitExpression(node, 0 /* OperatorPrecedence.Lowest */);
+    }
+    emitForStatement(node) {
+        const state = this.enterNode(node);
+        let pos = this.emitToken(98 /* SyntaxKind.ForKeyword */, node.pos, node);
+        this.space();
+        pos = this.emitToken(20 /* SyntaxKind.OpenParenToken */, pos, node);
+        if (node.initializer !== undefined) {
+            this.emitForInitializer(node.initializer);
+            pos = node.initializer.end;
+        }
+        pos = this.emitToken(26 /* SyntaxKind.SemicolonToken */, pos, node);
+        if (node.condition !== undefined) {
+            this.space();
+            this.emitExpression(node.condition, 0 /* OperatorPrecedence.Lowest */);
+            pos = node.condition.end;
+        }
+        pos = this.emitToken(26 /* SyntaxKind.SemicolonToken */, pos, node);
+        if (node.incrementor !== undefined) {
+            this.space();
+            this.emitExpression(node.incrementor, 0 /* OperatorPrecedence.Lowest */);
+            pos = node.incrementor.end;
+        }
+        this.emitToken(21 /* SyntaxKind.CloseParenToken */, pos, node);
+        this.emitEmbeddedStatement(node, node.statement);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitForInOrOfStatement(node) {
+        const state = this.enterNode(node);
+        const pos = this.emitToken(98 /* SyntaxKind.ForKeyword */, node.pos, node);
+        this.space();
+        if (node.kind === 251 /* SyntaxKind.ForOfStatement */ && node.awaitModifier !== undefined) {
+            this.emitOptionalToken(node.awaitModifier);
+            this.space();
+        }
+        this.emitToken(20 /* SyntaxKind.OpenParenToken */, pos, node);
+        this.emitForInitializer(node.initializer);
+        this.space();
+        this.emitToken(node.kind === 251 /* SyntaxKind.ForOfStatement */ ? 165 /* SyntaxKind.OfKeyword */ : 102 /* SyntaxKind.InKeyword */, node.initializer.end, node);
+        this.space();
+        this.emitExpression(node.expression, 0 /* OperatorPrecedence.Lowest */);
+        this.emitToken(21 /* SyntaxKind.CloseParenToken */, node.expression.end, node);
+        this.emitEmbeddedStatement(node, node.statement);
+        this.exitNode(node, state);
+        return true;
+    }
+    /** `break`, `continue` and `return` with their optional operand. */
+    emitJumpStatement(node, keyword, label, expression) {
+        const state = this.enterNode(node);
+        this.emitToken(keyword, node.pos, node);
+        if (label !== undefined) {
+            this.space();
+            this.emitIdentifierName(label);
+        }
+        if (expression !== undefined) {
+            this.space();
+            this.emitExpressionNoASI(expression, 0 /* OperatorPrecedence.Lowest */);
+        }
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTryStatement(node) {
+        const state = this.enterNode(node);
+        this.emitToken(112 /* SyntaxKind.TryKeyword */, node.pos, node);
+        this.space();
+        this.emitBlock(node.tryBlock);
+        const catchClause = node.catchClause;
+        if (catchClause !== undefined) {
+            this.writeLineOrSpace(node, node.tryBlock, catchClause);
+            this.emitCatchClause(catchClause);
+        }
+        if (node.finallyBlock !== undefined) {
+            const previous = catchClause !== undefined ? catchClause : node.tryBlock;
+            this.writeLineOrSpace(node, previous, node.finallyBlock);
+            this.emitToken(97 /* SyntaxKind.FinallyKeyword */, previous.end, node);
+            this.space();
+            this.emitBlock(node.finallyBlock);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitEmbeddedStatement(parent, node) {
+        if (node instanceof Block ||
+            this.shouldEmitOnSingleLine(parent) ||
+            (this.options.preserveSourceNewlines && this.getLeadingLineTerminatorCount(parent, node, 0 /* ListFormat.None */) === 0)) {
+            this.space();
+            return this.emitStatement(node);
+        }
+        this.line();
+        this.writer.indent++;
+        // An embedded empty statement is significant.
+        if (node instanceof EmptyStatement)
+            this.emitSimpleNode(node, ';');
+        else
+            this.emitStatement(node);
+        this.writer.indent--;
+        return true;
+    }
+    // Declarations
+    emitVariableDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitBindingName(node.name);
+        this.emitOptionalToken(node.exclamationToken);
+        this.emitTypeAnnotation(node.type);
+        let end = node.name.end;
+        if (node.type !== undefined && node.type.end > end)
+            end = node.type.end;
+        const erasedType = this.context.getTypeNode(node.name);
+        if (erasedType !== undefined && erasedType.end > end)
+            end = erasedType.end;
+        this.emitInitializer(node.initializer, end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitVariableDeclarationList(node) {
+        const state = this.enterNode(node);
+        switch (blockScopeFlags(node)) {
+            case 1 /* NodeFlags.Let */:
+                this.write1('let');
+                break;
+            case 2 /* NodeFlags.Const */:
+                this.write1('const');
+                break;
+            case 4 /* NodeFlags.Using */:
+                this.write1('using');
+                break;
+            case 6 /* NodeFlags.AwaitUsing */:
+                this.write1('await using');
+                break;
+            default:
+                this.write1('var');
+        }
+        this.space();
+        this.emitList(16 /* ListItem.VariableDeclaration */, node, node.declarations, 528 /* ListFormat.VariableDeclarationList */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitFunctionDeclaration(node) {
+        const state = this.enterNode(node);
+        this.generateNameIfNeeded(node.name);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('function');
+        this.emitOptionalToken(node.asteriskToken);
+        this.space();
+        if (node.name !== undefined)
+            this.emitIdentifierName(node.name);
+        this.emitScopedSignature(node, node.typeParameters, node.parameters, node.type, node.body, true);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitInterfaceDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('interface ');
+        this.emitBindingIdentifier(node.name);
+        this.emitTypeParameters(node, node.typeParameters);
+        this.emitList(17 /* ListItem.HeritageClause */, node, node.heritageClauses, 512 /* ListFormat.HeritageClauses */);
+        this.write1(' {');
+        this.pushNameGenerationScope(node);
+        this.generateAllMemberNames(node.members);
+        this.emitList(4 /* ListItem.TypeElement */, node, node.members, 129 /* ListFormat.InterfaceMembers */);
+        this.popNameGenerationScope(node);
+        this.write1('}');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitTypeAliasDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('type ');
+        this.emitBindingIdentifier(node.name);
+        this.emitTypeParameters(node, node.typeParameters);
+        this.write1(' = ');
+        this.emitTypeNodeOutsideExtends(node.type);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitEnumDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        this.write1('enum ');
+        this.emitBindingIdentifier(node.name);
+        this.write1(' {');
+        this.emitList(18 /* ListItem.EnumMember */, node, node.members, 145 /* ListFormat.EnumMembers */);
+        this.write1('}');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitModuleDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        if (node.keyword !== 162 /* SyntaxKind.GlobalKeyword */)
+            this.write1(node.keyword === 145 /* SyntaxKind.NamespaceKeyword */ ? 'namespace ' : 'module ');
+        this.emitIdentifierOrString(node.name, true);
+        let body = node.body;
+        while (body instanceof ModuleDeclaration) {
+            this.write1('.');
+            this.emitIdentifierOrString(body.name, false);
+            body = body.body;
+        }
+        if (body === undefined)
+            this.write1(';');
+        else if (body instanceof ModuleBlock) {
+            this.space();
+            this.emitBlockLike(body, body.statements, false);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    /** Module blocks and case blocks: braces around a statement or clause list. */
+    emitBlockLike(node, statements, caseBlock) {
+        const state = this.enterNode(node);
+        if (!caseBlock)
+            this.generateNames(node);
+        this.emitToken(18 /* SyntaxKind.OpenBraceToken */, node.pos, node);
+        let format;
+        if (caseBlock)
+            format = 129 /* ListFormat.CaseBlockClauses */;
+        else
+            format =
+                this.isEmptyBlock(node, statements) || this.shouldEmitOnSingleLine(node)
+                    ? 768 /* ListFormat.SingleLineBlockStatements */
+                    : 129 /* ListFormat.MultiLineBlockStatements */;
+        this.emitList(caseBlock ? 19 /* ListItem.CaseOrDefaultClause */ : 15 /* ListItem.Statement */, node, statements, format);
+        this.emitTokenEx(19 /* SyntaxKind.CloseBraceToken */, statements.end, node, caseBlock || (format & 1 /* ListFormat.MultiLine */) !== 0 ? 2 /* TokenEmitFlags.IndentLeadingComments */ : 0 /* TokenEmitFlags.None */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitImportEqualsDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        const modifiersEnd = node.modifiers !== undefined && node.modifiers.end > node.pos ? node.modifiers.end : node.pos;
+        const pos = this.emitToken(101 /* SyntaxKind.ImportKeyword */, modifiersEnd, node);
+        this.space();
+        if (node.isTypeOnly) {
+            this.emitToken(156 /* SyntaxKind.TypeKeyword */, pos, node);
+            this.space();
+        }
+        this.emitBindingIdentifier(node.name);
+        this.space();
+        this.emitToken(63 /* SyntaxKind.EqualsToken */, node.name.end, node);
+        this.space();
+        const reference = node.moduleReference;
+        if (reference instanceof Identifier)
+            this.emitIdentifierReference(reference);
+        else if (reference instanceof QualifiedName)
+            this.emitQualifiedName(reference);
+        else if (reference instanceof ExternalModuleReference) {
+            const referenceState = this.enterNode(reference);
+            this.write1('require(');
+            this.emitExpression(reference.expression, 2 /* OperatorPrecedence.DisallowComma */);
+            this.write1(')');
+            this.exitNode(reference, referenceState);
+        }
+        else
+            throw new Error('Unexpected module reference ' + reference.kind);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitImportDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        const modifiersEnd = node.modifiers !== undefined && node.modifiers.end > node.pos ? node.modifiers.end : node.pos;
+        this.emitToken(101 /* SyntaxKind.ImportKeyword */, modifiersEnd, node);
+        this.space();
+        const clause = node.importClause;
+        if (clause !== undefined) {
+            this.emitImportClause(clause);
+            this.space();
+            this.emitToken(161 /* SyntaxKind.FromKeyword */, clause.end, node);
+            this.space();
+        }
+        this.emitExpression(node.moduleSpecifier, 0 /* OperatorPrecedence.Lowest */);
+        if (node.attributes !== undefined) {
+            this.space();
+            this.emitImportAttributes(node.attributes);
+        }
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitImportClause(node) {
+        const state = this.enterNode(node);
+        if (node.phaseModifier !== undefined && node.phaseModifier !== 0 /* SyntaxKind.Unknown */) {
+            this.emitToken(node.phaseModifier, node.pos, node);
+            this.space();
+        }
+        const name = node.name;
+        if (name !== undefined) {
+            this.emitBindingIdentifier(name);
+            if (node.namedBindings !== undefined) {
+                this.emitToken(27 /* SyntaxKind.CommaToken */, name.end, node);
+                this.space();
+            }
+        }
+        const bindings = node.namedBindings;
+        if (bindings instanceof NamespaceImport) {
+            const bindingsState = this.enterNode(bindings);
+            const pos = this.emitToken(41 /* SyntaxKind.AsteriskToken */, bindings.pos, bindings);
+            this.space();
+            this.emitToken(129 /* SyntaxKind.AsKeyword */, pos, bindings);
+            this.space();
+            this.emitBindingIdentifier(bindings.name);
+            this.exitNode(bindings, bindingsState);
+        }
+        else if (bindings instanceof NamedImports) {
+            const bindingsState = this.enterNode(bindings);
+            this.write1('{');
+            this.emitList(20 /* ListItem.ImportSpecifier */, bindings, bindings.elements, 525136 /* ListFormat.NamedImportsOrExportsElements */);
+            this.write1('}');
+            this.exitNode(bindings, bindingsState);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    /** Import and export specifiers. */
+    emitSpecifier(node, isTypeOnly, propertyName, name, binding) {
+        const state = this.enterNode(node);
+        if (isTypeOnly)
+            this.write1('type ');
+        if (propertyName !== undefined) {
+            this.emitIdentifierOrString(propertyName, false);
+            this.space();
+            this.emitToken(129 /* SyntaxKind.AsKeyword */, propertyName.end, node);
+            this.space();
+        }
+        this.emitIdentifierOrString(name, binding);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitExportAssignment(node) {
+        const state = this.enterNode(node);
+        const nextPos = this.emitToken(94 /* SyntaxKind.ExportKeyword */, node.pos, node);
+        this.space();
+        this.emitToken(node.isExportEquals ? 63 /* SyntaxKind.EqualsToken */ : 89 /* SyntaxKind.DefaultKeyword */, nextPos, node);
+        this.space();
+        if (node.isExportEquals)
+            this.emitExpression(node.expression, 3 /* OperatorPrecedence.Assignment */);
+        else {
+            const leftmost = getLeftmostExpression(node.expression, false).kind;
+            this.emitExpression(node.expression, leftmost === 232 /* SyntaxKind.ClassExpression */ || leftmost === 219 /* SyntaxKind.FunctionExpression */
+                ? 22 /* OperatorPrecedence.Parentheses */
+                : 3 /* OperatorPrecedence.Assignment */);
+        }
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitExportDeclaration(node) {
+        const state = this.enterNode(node);
+        this.emitModifierList(node, node.modifiers, false);
+        let pos = this.emitToken(94 /* SyntaxKind.ExportKeyword */, node.pos, node);
+        this.space();
+        if (node.isTypeOnly) {
+            pos = this.emitToken(156 /* SyntaxKind.TypeKeyword */, pos, node);
+            this.space();
+        }
+        const clause = node.exportClause;
+        if (clause instanceof NamespaceExport) {
+            const clauseState = this.enterNode(clause);
+            const asteriskEnd = this.emitToken(41 /* SyntaxKind.AsteriskToken */, clause.pos, clause);
+            this.space();
+            this.emitToken(129 /* SyntaxKind.AsKeyword */, asteriskEnd, clause);
+            this.space();
+            this.emitIdentifierOrString(clause.name, false);
+            this.exitNode(clause, clauseState);
+        }
+        else if (clause instanceof NamedExports) {
+            const clauseState = this.enterNode(clause);
+            this.write1('{');
+            this.emitList(21 /* ListItem.ExportSpecifier */, clause, clause.elements, 525136 /* ListFormat.NamedImportsOrExportsElements */);
+            this.write1('}');
+            this.exitNode(clause, clauseState);
+        }
+        else
+            pos = this.emitToken(41 /* SyntaxKind.AsteriskToken */, pos, node);
+        if (node.moduleSpecifier !== undefined) {
+            this.space();
+            this.emitToken(161 /* SyntaxKind.FromKeyword */, clause !== undefined && clause.end > pos ? clause.end : pos, node);
+            this.space();
+            this.emitExpression(node.moduleSpecifier, 0 /* OperatorPrecedence.Lowest */);
+        }
+        if (node.attributes !== undefined) {
+            this.space();
+            this.emitImportAttributes(node.attributes);
+        }
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitImportAttributes(node) {
+        const state = this.enterNode(node);
+        this.emitToken(node.token, node.pos, node);
+        this.space();
+        this.emitList(10 /* ListItem.ImportAttribute */, node, node.attributes, 526226 /* ListFormat.ImportAttributes */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitImportAttribute(node) {
+        const state = this.enterNode(node);
+        if (node.name !== undefined)
+            this.emitIdentifierOrString(node.name, false);
+        this.write1(': ');
+        const value = node.value;
+        if (!this.hasEmitFlag(value, 128 /* EmitFlags.NoLeadingComments */))
+            this.emitTrailingComments(this.context.commentPos(value), 2 /* CommentSeparator.After */);
+        this.emitExpression(value, 2 /* OperatorPrecedence.DisallowComma */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitNamespaceExportDeclaration(node) {
+        const state = this.enterNode(node);
+        let pos = this.emitToken(94 /* SyntaxKind.ExportKeyword */, node.pos, node);
+        this.space();
+        pos = this.emitToken(129 /* SyntaxKind.AsKeyword */, pos, node);
+        this.space();
+        this.emitToken(145 /* SyntaxKind.NamespaceKeyword */, pos, node);
+        this.space();
+        this.emitBindingIdentifier(node.name);
+        this.write1(';');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitStatement(node) {
+        switch (node.kind) {
+            case 242 /* SyntaxKind.Block */:
+                if (node instanceof Block)
+                    return this.emitBlock(node);
+                break;
+            case 243 /* SyntaxKind.EmptyStatement */:
+                return this.emitSimpleNode(node, ';');
+            case 244 /* SyntaxKind.VariableStatement */:
+                if (node instanceof VariableStatement)
+                    return this.emitVariableStatement(node);
+                break;
+            case 245 /* SyntaxKind.ExpressionStatement */:
+                if (node instanceof ExpressionStatement)
+                    return this.emitExpressionStatement(node);
+                break;
+            case 246 /* SyntaxKind.IfStatement */:
+                if (node instanceof IfStatement)
+                    return this.emitIfStatement(node);
+                break;
+            case 247 /* SyntaxKind.DoStatement */:
+                if (node instanceof DoStatement)
+                    return this.emitDoStatement(node);
+                break;
+            case 248 /* SyntaxKind.WhileStatement */:
+                if (node instanceof WhileStatement) {
+                    const state = this.enterNode(node);
+                    this.emitKeywordAndParenthesizedExpression(node, 116 /* SyntaxKind.WhileKeyword */, node.pos, node.expression);
+                    this.emitEmbeddedStatement(node, node.statement);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 249 /* SyntaxKind.ForStatement */:
+                if (node instanceof ForStatement)
+                    return this.emitForStatement(node);
+                break;
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+                if (node instanceof ForInOrOfStatement)
+                    return this.emitForInOrOfStatement(node);
+                break;
+            case 252 /* SyntaxKind.ContinueStatement */:
+                if (node instanceof ContinueStatement)
+                    return this.emitJumpStatement(node, 87 /* SyntaxKind.ContinueKeyword */, node.label, undefined);
+                break;
+            case 253 /* SyntaxKind.BreakStatement */:
+                if (node instanceof BreakStatement)
+                    return this.emitJumpStatement(node, 82 /* SyntaxKind.BreakKeyword */, node.label, undefined);
+                break;
+            case 254 /* SyntaxKind.ReturnStatement */:
+                if (node instanceof ReturnStatement)
+                    return this.emitJumpStatement(node, 106 /* SyntaxKind.ReturnKeyword */, undefined, node.expression);
+                break;
+            case 255 /* SyntaxKind.WithStatement */:
+                if (node instanceof WithStatement) {
+                    const state = this.enterNode(node);
+                    this.emitKeywordAndParenthesizedExpression(node, 117 /* SyntaxKind.WithKeyword */, node.pos, node.expression);
+                    this.emitEmbeddedStatement(node, node.statement);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 256 /* SyntaxKind.SwitchStatement */:
+                if (node instanceof SwitchStatement) {
+                    const state = this.enterNode(node);
+                    this.emitKeywordAndParenthesizedExpression(node, 108 /* SyntaxKind.SwitchKeyword */, node.pos, node.expression);
+                    this.space();
+                    this.emitBlockLike(node.caseBlock, node.caseBlock.clauses, true);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 257 /* SyntaxKind.LabeledStatement */:
+                if (node instanceof LabeledStatement) {
+                    const state = this.enterNode(node);
+                    this.emitIdentifierName(node.label);
+                    this.emitToken(58 /* SyntaxKind.ColonToken */, node.label.end, node);
+                    this.space();
+                    this.emitStatement(node.statement);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 258 /* SyntaxKind.ThrowStatement */:
+                if (node instanceof ThrowStatement) {
+                    const state = this.enterNode(node);
+                    this.emitToken(110 /* SyntaxKind.ThrowKeyword */, node.pos, node);
+                    this.space();
+                    this.emitExpressionNoASI(node.expression, 0 /* OperatorPrecedence.Lowest */);
+                    this.write1(';');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 259 /* SyntaxKind.TryStatement */:
+                if (node instanceof TryStatement)
+                    return this.emitTryStatement(node);
+                break;
+            case 260 /* SyntaxKind.DebuggerStatement */:
+                if (node instanceof DebuggerStatement) {
+                    const state = this.enterNode(node);
+                    this.emitToken(88 /* SyntaxKind.DebuggerKeyword */, node.pos, node);
+                    this.write1(';');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 347 /* SyntaxKind.NotEmittedStatement */:
+                return this.emitSimpleNode(node, '');
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+                if (node instanceof FunctionDeclaration)
+                    return this.emitFunctionDeclaration(node);
+                break;
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                if (node instanceof ClassDeclaration)
+                    return this.emitClassLike(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
+                break;
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+                if (node instanceof InterfaceDeclaration)
+                    return this.emitInterfaceDeclaration(node);
+                break;
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                if (node instanceof TypeAliasDeclaration)
+                    return this.emitTypeAliasDeclaration(node);
+                break;
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                if (node instanceof EnumDeclaration)
+                    return this.emitEnumDeclaration(node);
+                break;
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                if (node instanceof ModuleDeclaration)
+                    return this.emitModuleDeclaration(node);
+                break;
+            case 283 /* SyntaxKind.MissingDeclaration */:
+                return false;
+            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+                if (node instanceof NamespaceExportDeclaration)
+                    return this.emitNamespaceExportDeclaration(node);
+                break;
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (node instanceof ImportEqualsDeclaration)
+                    return this.emitImportEqualsDeclaration(node);
+                break;
+            case 273 /* SyntaxKind.ImportDeclaration */:
+                if (node instanceof ImportDeclaration)
+                    return this.emitImportDeclaration(node);
+                break;
+            case 278 /* SyntaxKind.ExportAssignment */:
+                if (node instanceof ExportAssignment)
+                    return this.emitExportAssignment(node);
+                break;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                if (node instanceof ExportDeclaration)
+                    return this.emitExportDeclaration(node);
+                break;
+        }
+        throw new Error('Unexpected statement ' + node.kind);
+    }
+    // JSX
+    emitJsxElement(node) {
+        const state = this.enterNode(node);
+        this.emitJsxOpeningElement(node.openingElement);
+        this.emitList(23 /* ListItem.JsxChild */, node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
+        this.emitJsxClosingElement(node.closingElement);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxSelfClosingElement(node) {
+        const state = this.enterNode(node);
+        this.write1('<');
+        this.emitJsxTagName(node.tagName);
+        this.emitTypeArguments(node, node.typeArguments);
+        this.space();
+        this.emitJsxAttributes(node.attributes);
+        this.write1('/>');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxFragment(node) {
+        const state = this.enterNode(node);
+        this.emitSimpleNode(node.openingFragment, '<>');
+        this.emitList(23 /* ListItem.JsxChild */, node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
+        this.emitSimpleNode(node.closingFragment, '</>');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxOpeningElement(node) {
+        const state = this.enterNode(node);
+        this.write1('<');
+        const indented = this.writeLineSeparatorsAndIndentBefore(node.tagName, node);
+        this.emitJsxTagName(node.tagName);
+        this.emitTypeArguments(node, node.typeArguments);
+        if (node.attributes.properties.nodes.length > 0)
+            this.space();
+        this.emitJsxAttributes(node.attributes);
+        this.writeLineSeparatorsAfter(node.attributes, node);
+        this.indentIf(indented, -1);
+        this.write1('>');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxClosingElement(node) {
+        const state = this.enterNode(node);
+        this.write1('</');
+        this.emitJsxTagName(node.tagName);
+        this.write1('>');
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxAttributes(node) {
+        const state = this.enterNode(node);
+        this.emitList(24 /* ListItem.JsxAttributeLike */, node, node.properties, 262656 /* ListFormat.JsxElementAttributes */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxAttribute(node) {
+        const state = this.enterNode(node);
+        this.emitJsxName(node.name);
+        const initializer = node.initializer;
+        if (initializer !== undefined) {
+            this.write1('=');
+            if (initializer instanceof StringLiteral)
+                this.emitLiteral(initializer);
+            else if (initializer instanceof JsxExpression)
+                this.emitJsxExpression(initializer);
+            else if (initializer instanceof JsxElement)
+                this.emitJsxElement(initializer);
+            else if (initializer instanceof JsxSelfClosingElement)
+                this.emitJsxSelfClosingElement(initializer);
+            else if (initializer instanceof JsxFragment)
+                this.emitJsxFragment(initializer);
+            else
+                this.emitExpression(initializer, 0 /* OperatorPrecedence.Lowest */);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxExpression(node) {
+        const state = this.enterNode(node);
+        if (node.expression !== undefined ||
+            (!this.commentsDisabled && !nodeIsSynthesized(node) && this.hasCommentsAtPosition(node.pos))) {
+            const indented = this.currentSourceFile !== undefined &&
+                !nodeIsSynthesized(node) &&
+                getLinesBetweenPositions(this.lineStarts, node.pos, node.end) !== 0;
+            this.indentIf(indented, 1);
+            let end = this.emitToken(18 /* SyntaxKind.OpenBraceToken */, node.pos, node);
+            this.emitOptionalToken(node.dotDotDotToken);
+            if (node.expression !== undefined)
+                this.emitExpression(node.expression, 2 /* OperatorPrecedence.DisallowComma */);
+            if (node.expression !== undefined && node.expression.end > end)
+                end = node.expression.end;
+            if (node.dotDotDotToken !== undefined && node.dotDotDotToken.end > end)
+                end = node.dotDotDotToken.end;
+            this.emitToken(19 /* SyntaxKind.CloseBraceToken */, end, node);
+            this.indentIf(indented, -1);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitJsxName(node) {
+        if (node === undefined)
+            return false;
+        if (node instanceof Identifier)
+            return this.emitIdentifierName(node);
+        if (node instanceof JsxNamespacedName) {
+            const state = this.enterNode(node);
+            this.emitIdentifierName(node.namespace);
+            this.write1(':');
+            this.emitIdentifierName(node.name);
+            this.exitNode(node, state);
+            return true;
+        }
+        throw new Error('Unexpected JSX name ' + node.kind);
+    }
+    emitJsxTagName(node) {
+        if (node instanceof Identifier)
+            return this.emitIdentifierReference(node);
+        if (node instanceof PropertyAccessExpression)
+            return this.emitPropertyAccessExpression(node);
+        if (node.kind === 109 /* SyntaxKind.ThisKeyword */)
+            return this.emitTokenNode(node);
+        return this.emitJsxName(node);
+    }
+    // Typed `Node | undefined` (with a check) so scriptc narrows elements read from arrays.
+    emitJsxChild(node) {
+        if (node === undefined)
+            return false;
+        if (node instanceof JsxText) {
+            const state = this.enterNode(node);
+            this.writer.writeText(node.text);
+            this.exitNode(node, state);
+            return true;
+        }
+        if (node instanceof JsxExpression)
+            return this.emitJsxExpression(node);
+        if (node instanceof JsxElement)
+            return this.emitJsxElement(node);
+        if (node instanceof JsxSelfClosingElement)
+            return this.emitJsxSelfClosingElement(node);
+        if (node instanceof JsxFragment)
+            return this.emitJsxFragment(node);
+        throw new Error('Unexpected JSX child ' + node.kind);
+    }
+    // Clauses
+    emitCaseOrDefaultClause(node) {
+        const state = this.enterNode(node);
+        let colonPos;
+        if (node.kind === 297 /* SyntaxKind.CaseClause */ && node.expression !== undefined) {
+            this.emitToken(83 /* SyntaxKind.CaseKeyword */, node.pos, node);
+            this.space();
+            this.emitExpression(node.expression, 0 /* OperatorPrecedence.Lowest */);
+            colonPos = node.expression.end;
+        }
+        else
+            colonPos = this.emitToken(89 /* SyntaxKind.DefaultKeyword */, node.pos, node);
+        const statements = node.statements.nodes;
+        const single = statements.length === 1 &&
+            (this.currentSourceFile === undefined ||
+                nodeIsSynthesized(node) ||
+                nodeIsSynthesized(statements[0]) ||
+                this.positionsAreOnSameLine(this.rangeStart(node.pos), this.rangeStart(statements[0].pos)));
+        let format = 163969 /* ListFormat.CaseOrDefaultClauseStatements */;
+        if (single) {
+            // The statement list emits the colon's trailing comments.
+            this.writeTokenText(58 /* SyntaxKind.ColonToken */, colonPos);
+            this.space();
+            format &= ~(1 /* ListFormat.MultiLine */ | 128 /* ListFormat.Indented */);
+        }
+        else
+            this.emitToken(58 /* SyntaxKind.ColonToken */, colonPos, node);
+        this.emitList(15 /* ListItem.Statement */, node, node.statements, format);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitHeritageClause(node) {
+        const state = this.enterNode(node);
+        this.space();
+        this.emitToken(node.token, node.pos, node);
+        this.space();
+        this.emitList(22 /* ListItem.ExpressionWithTypeArguments */, node, node.types, 528 /* ListFormat.HeritageClauseTypes */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitCatchClause(node) {
+        const state = this.enterNode(node);
+        const openParenPos = this.emitToken(84 /* SyntaxKind.CatchKeyword */, node.pos, node);
+        this.space();
+        const declaration = node.variableDeclaration;
+        if (declaration !== undefined) {
+            this.emitToken(20 /* SyntaxKind.OpenParenToken */, openParenPos, node);
+            this.emitVariableDeclaration(declaration);
+            this.emitToken(21 /* SyntaxKind.CloseParenToken */, declaration.end, node);
+            this.space();
+        }
+        this.emitBlock(node.block);
+        this.exitNode(node, state);
+        return true;
+    }
+    // Property assignments
+    emitPropertyAssignment(node) {
+        const state = this.enterNode(node);
+        this.emitPropertyName(node.name);
+        this.write1(': ');
+        // `{ id: /*comment*/ () => {} }`: the comment trails the colon rather than leading the initializer.
+        const initializer = node.initializer;
+        if (!this.hasEmitFlag(initializer, 128 /* EmitFlags.NoLeadingComments */))
+            this.emitTrailingComments(this.context.commentPos(initializer), 2 /* CommentSeparator.After */);
+        this.emitExpression(initializer, 2 /* OperatorPrecedence.DisallowComma */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitShorthandPropertyAssignment(node) {
+        const state = this.enterNode(node);
+        this.emitPropertyName(node.name);
+        if (node.objectAssignmentInitializer !== undefined) {
+            this.write1(' = ');
+            this.emitExpression(node.objectAssignmentInitializer, 2 /* OperatorPrecedence.DisallowComma */);
+        }
+        this.exitNode(node, state);
+        return true;
+    }
+    emitSpreadAssignment(node) {
+        const state = this.enterNode(node);
+        this.emitToken(25 /* SyntaxKind.DotDotDotToken */, node.pos, node);
+        this.emitExpression(node.expression, 2 /* OperatorPrecedence.DisallowComma */);
+        this.exitNode(node, state);
+        return true;
+    }
+    emitEnumMember(node) {
+        const state = this.enterNode(node);
+        this.emitPropertyName(node.name);
+        this.emitInitializer(node.initializer, node.name.end, node);
+        this.exitNode(node, state);
+        return true;
+    }
+    // Source files
+    emitPrologueDirectives(statements) {
+        const nodes = statements.nodes;
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (!isPrologueDirective(node))
+                return i;
+            this.line();
+            this.emitStatement(node);
+        }
+        return nodes.length;
+    }
+    emitHelpers(node) {
+        const nodeHelpers = this.context.getEmitHelpers(node);
+        if (nodeHelpers === undefined || nodeHelpers.length === 0)
+            return false;
+        const file = this.currentSourceFile;
+        const shouldSkip = this.options.noEmitHelpers || (file !== undefined && this.context.hasRecordedExternalHelpers(file));
+        const helpers = nodeHelpers.slice();
+        helpers.sort(compareEmitHelpers);
+        let emitted = false;
+        for (const helper of helpers) {
+            if (!helper.scoped && shouldSkip)
+                continue;
+            let text = helper.text;
+            if (helper.uniqueName.length > 0)
+                text = text.split('{name}').join(this.nameGenerator.makeFileLevelOptimisticUniqueName(helper.uniqueName));
+            this.writeLinesOfText(text);
+            emitted = true;
+        }
+        return emitted;
+    }
+    emitSourceFileNode(node) {
+        const savedSourceFile = this.currentSourceFile;
+        const savedCommentsDisabled = this.commentsDisabled;
+        this.setCurrentSourceFile(node);
+        this.line();
+        this.pushNameGenerationScope(node);
+        this.generateAllNames(node.statements);
+        let index = 0;
+        let detached;
+        if (node.scriptKind !== 6 /* ScriptKind.JSON */) {
+            if (!nodeIsSynthesized(node)) {
+                const shebang = getShebang(node.text);
+                if (shebang.length > 0) {
+                    this.writer.writeComment(shebang);
+                    this.line();
+                }
+            }
+            index = this.emitPrologueDirectives(node.statements);
+            if (!this.writer.isAtStartOfLine())
+                this.line();
+            detached = this.emitDetachedCommentsBeforeStatementList(node, node.statements.pos);
+            this.emitHelpers(node);
+            if (node.isDeclarationFile)
+                this.emitTripleSlashDirectives(node);
+        }
+        else
+            detached = this.emitDetachedCommentsBeforeStatementList(node, node.statements.pos);
+        this.emitListRange(15 /* ListItem.Statement */, node, node.statements, 1 /* ListFormat.MultiLine */, index);
+        this.popNameGenerationScope(node);
+        this.emitDetachedCommentsAfterStatementList(node, node.statements.end, detached);
+        this.setCurrentSourceFile(savedSourceFile);
+        this.commentsDisabled = savedCommentsDisabled;
+        return true;
+    }
+    emitTripleSlashDirectives(node) {
+        this.emitDirectives('path', node.referencedFiles);
+        this.emitDirectives('types', node.typeReferenceDirectives);
+        return this.emitDirectives('lib', node.libReferenceDirectives);
+    }
+    emitDirectives(kind, refs) {
+        for (const ref of refs) {
+            let mode = '';
+            if (ref.resolutionMode !== 0)
+                mode = 'resolution-mode="' + (ref.resolutionMode === 99 ? 'import' : 'require') + '" ';
+            this.writer.writeComment('/// <reference ' + kind + '="' + ref.fileName + '" ' + mode + (ref.preserve ? 'preserve="true" ' : '') + '/>');
+            this.line();
+        }
+        return true;
+    }
+    // Lists
+    // Typed `Node | undefined` (with a check) so scriptc narrows elements read from arrays.
+    emitListItem(item, node) {
+        if (node === undefined)
+            return false;
+        switch (item) {
+            case 0 /* ListItem.Keyword */:
+                return this.emitTokenNode(node);
+            case 1 /* ListItem.ModifierLike */:
+                if (node instanceof Decorator)
+                    return this.emitDecorator(node);
+                if (isModifier(node))
+                    return this.emitTokenNode(node);
+                break;
+            case 2 /* ListItem.TypeParameter */:
+                if (node instanceof TypeParameterDeclaration)
+                    return this.emitTypeParameter(node);
+                return this.emitTypeNodeOutsideExtends(node);
+            case 3 /* ListItem.Parameter */:
+                if (node instanceof ParameterDeclaration)
+                    return this.emitParameter(node);
+                break;
+            case 4 /* ListItem.TypeElement */:
+                return this.emitTypeElement(node);
+            case 5 /* ListItem.ClassElement */:
+                return this.emitClassElement(node);
+            case 6 /* ListItem.ObjectLiteralElement */:
+                return this.emitObjectLiteralElement(node);
+            case 7 /* ListItem.TypeArgument */:
+                if (node instanceof TypeParameterDeclaration)
+                    return this.emitTypeParameter(node);
+                return this.emitTypeNodeOutsideExtends(node);
+            case 8 /* ListItem.UnionConstituent */:
+                return this.emitTypeNode(node, 5 /* TypePrecedence.TypeOperator */);
+            case 9 /* ListItem.TemplateTypeSpan */:
+                if (node instanceof TemplateLiteralTypeSpan)
+                    return this.emitTemplateTypeSpan(node);
+                break;
+            case 10 /* ListItem.ImportAttribute */:
+                if (node instanceof ImportAttribute)
+                    return this.emitImportAttribute(node);
+                break;
+            case 11 /* ListItem.BindingElement */:
+                if (node instanceof BindingElement)
+                    return this.emitBindingElement(node);
+                break;
+            case 12 /* ListItem.ArrayElement */:
+            case 13 /* ListItem.Argument */:
+                return this.emitExpression(node, 1 /* OperatorPrecedence.Spread */);
+            case 14 /* ListItem.TemplateSpan */:
+                if (node instanceof TemplateSpan) {
+                    const state = this.enterNode(node);
+                    this.emitExpression(node.expression, 0 /* OperatorPrecedence.Comma */);
+                    this.emitLiteral(node.literal);
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+            case 15 /* ListItem.Statement */:
+                return this.emitStatement(node);
+            case 16 /* ListItem.VariableDeclaration */:
+                if (node instanceof VariableDeclaration)
+                    return this.emitVariableDeclaration(node);
+                break;
+            case 17 /* ListItem.HeritageClause */:
+                if (node instanceof HeritageClause)
+                    return this.emitHeritageClause(node);
+                break;
+            case 18 /* ListItem.EnumMember */:
+                if (node instanceof EnumMember)
+                    return this.emitEnumMember(node);
+                break;
+            case 19 /* ListItem.CaseOrDefaultClause */:
+                if (node instanceof CaseOrDefaultClause)
+                    return this.emitCaseOrDefaultClause(node);
+                break;
+            case 20 /* ListItem.ImportSpecifier */:
+                if (node instanceof ImportSpecifier)
+                    return this.emitSpecifier(node, node.isTypeOnly, node.propertyName, node.name, true);
+                break;
+            case 21 /* ListItem.ExportSpecifier */:
+                if (node instanceof ExportSpecifier)
+                    return this.emitSpecifier(node, node.isTypeOnly, node.propertyName, node.name, false);
+                break;
+            case 22 /* ListItem.ExpressionWithTypeArguments */:
+                if (node instanceof ExpressionWithTypeArguments)
+                    return this.emitExpressionWithTypeArguments(node);
+                break;
+            case 23 /* ListItem.JsxChild */:
+                return this.emitJsxChild(node);
+            case 24 /* ListItem.JsxAttributeLike */:
+                if (node instanceof JsxAttribute)
+                    return this.emitJsxAttribute(node);
+                if (node instanceof JsxSpreadAttribute) {
+                    const state = this.enterNode(node);
+                    this.write1('{...');
+                    this.emitExpression(node.expression, 0 /* OperatorPrecedence.Lowest */);
+                    this.write1('}');
+                    this.exitNode(node, state);
+                    return true;
+                }
+                break;
+        }
+        throw new Error('Unexpected list element ' + node.kind);
+    }
+    emitList(item, parent, children, format) {
+        if (this.hasEmitFlag(parent, 2 /* EmitFlags.MultiLine */))
+            format |= 65536 /* ListFormat.PreferNewLine */ | 128 /* ListFormat.Indented */;
+        return this.emitListRange(item, parent, children, format, 0);
+    }
+    emitListRange(item, parent, children, format, start) {
+        if (children === undefined && (format & 16384 /* ListFormat.OptionalIfNil */) !== 0)
+            return false;
+        const length = children === undefined ? 0 : children.nodes.length;
+        const isEmpty = children === undefined || start >= length;
+        if (isEmpty && (format & 32768 /* ListFormat.OptionalIfEmpty */) !== 0)
+            return false;
+        const brackets = (format & 15360 /* ListFormat.BracketsMask */) !== 0;
+        if (brackets) {
+            this.write1(openingBracket(format));
+            if (isEmpty && children !== undefined)
+                this.emitTrailingComments(children.pos, 1 /* CommentSeparator.Before */);
+        }
+        if (isEmpty) {
+            if ((format & 1 /* ListFormat.MultiLine */) !== 0 &&
+                !(this.options.preserveSourceNewlines &&
+                    (parent === undefined || (this.currentSourceFile !== undefined && this.rangeIsOnSingleLine(parent)))))
+                this.line();
+            else if ((format & 256 /* ListFormat.SpaceBetweenBraces */) !== 0 && (format & 524288 /* ListFormat.NoSpaceIfEmpty */) === 0)
+                this.space();
+        }
+        else
+            this.emitListItems(item, parent, children.nodes, start, length, format, this.hasTrailingComma(parent, children), children.pos, children.end);
+        if (brackets) {
+            if (isEmpty && children !== undefined)
+                this.emitLeadingComments(children.end, false);
+            this.write1(closingBracket(format));
+        }
+        return true;
+    }
+    /** Whether to keep a list's trailing comma; for transformed nodes, as in the original list. */
+    hasTrailingComma(parent, children) {
+        if (!children.hasTrailingComma())
+            return false;
+        const original = this.context.mostOriginal(parent);
+        if (original === parent)
+            return true;
+        if (original.kind !== parent.kind)
+            return false;
+        let originalList = children;
+        switch (original.kind) {
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+                originalList = getProperties(original);
+                break;
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 207 /* SyntaxKind.ObjectBindingPattern */:
+            case 208 /* SyntaxKind.ArrayBindingPattern */:
+            case 276 /* SyntaxKind.NamedImports */:
+            case 280 /* SyntaxKind.NamedExports */:
+                originalList = getElements(original);
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.NewExpression */:
+                if (children === getTypeArguments(parent))
+                    originalList = getTypeArguments(original);
+                else if (children === getArguments(parent))
+                    originalList = getArguments(original);
+                break;
+            case 177 /* SyntaxKind.Constructor */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.ArrowFunction */:
+            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.ConstructorType */:
+            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+                if (children === getTypeParameters(parent))
+                    originalList = getTypeParameters(original);
+                else if (children === getParameters(parent))
+                    originalList = getParameters(original);
+                break;
+            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 232 /* SyntaxKind.ClassExpression */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                if (children === getTypeParameters(parent))
+                    originalList = getTypeParameters(original);
+                break;
+            case 301 /* SyntaxKind.ImportAttributes */:
+                if (original instanceof ImportAttributes)
+                    originalList = original.attributes;
+                break;
+        }
+        return originalList !== undefined && originalList.hasTrailingComma();
+    }
+    writeDelimiter(format) {
+        switch (format & 60 /* ListFormat.DelimitersMask */) {
+            case 16 /* ListFormat.CommaDelimited */:
+                return this.write1(',');
+            case 4 /* ListFormat.BarDelimited */:
+                return this.write1(' |');
+            case 32 /* ListFormat.AsteriskDelimited */:
+                return this.write1(' * ');
+            case 8 /* ListFormat.AmpersandDelimited */:
+                return this.write1(' &');
+        }
+        return false;
+    }
+    emitListItems(item, parent, nodes, start, end, format, hasTrailingComma, childrenPos, childrenEnd) {
+        const mayEmitInterveningComments = (format & 262144 /* ListFormat.NoInterveningComments */) === 0;
+        let shouldEmitInterveningComments = mayEmitInterveningComments;
+        const leadingLineTerminatorCount = end > start ? this.getLeadingLineTerminatorCount(parent, nodes[start], format) : 0;
+        if (leadingLineTerminatorCount > 0) {
+            this.lines(leadingLineTerminatorCount);
+            shouldEmitInterveningComments = false;
+        }
+        else if ((format & 256 /* ListFormat.SpaceBetweenBraces */) !== 0)
+            this.space();
+        if ((format & 128 /* ListFormat.Indented */) !== 0)
+            this.writer.indent++;
+        const parentEnd = parent.end;
+        let previous = undefined;
+        let shouldDecreaseIndentAfterEmit = false;
+        for (let i = start; i < end; i++) {
+            const child = nodes[i];
+            if ((format & 32 /* ListFormat.AsteriskDelimited */) !== 0) {
+                this.line();
+                this.writeDelimiter(format);
+            }
+            else if (previous !== undefined) {
+                // A comment between an element and its delimiter, on a line of its own, leads the delimiter.
+                if ((format & 60 /* ListFormat.DelimitersMask */) !== 0 &&
+                    previous.end !== parentEnd &&
+                    !this.commentsDisabled &&
+                    !this.hasEmitFlag(previous, 256 /* EmitFlags.NoTrailingComments */))
+                    this.emitLeadingComments(previous.end, false);
+                this.writeDelimiter(format);
+                const separating = this.getSeparatingLineTerminatorCount(previous, child, format);
+                if (separating > 0) {
+                    if ((format & (3 /* ListFormat.LinesMask */ | 128 /* ListFormat.Indented */)) === 0) {
+                        this.writer.indent++;
+                        shouldDecreaseIndentAfterEmit = true;
+                    }
+                    if (shouldEmitInterveningComments &&
+                        (format & 60 /* ListFormat.DelimitersMask */) !== 0 &&
+                        !positionIsSynthesized(child.pos) &&
+                        !this.hasEmitFlag(child, 128 /* EmitFlags.NoLeadingComments */))
+                        this.emitTrailingCommentsOfPosition(this.context.commentPos(child), (format & 512 /* ListFormat.SpaceBetweenSiblings */) !== 0, true);
+                    this.lines(separating);
+                    shouldEmitInterveningComments = false;
+                }
+                else if ((format & 512 /* ListFormat.SpaceBetweenSiblings */) !== 0)
+                    this.space();
+            }
+            if (shouldEmitInterveningComments && !this.hasEmitFlag(child, 128 /* EmitFlags.NoLeadingComments */))
+                this.emitTrailingCommentsOfPosition(this.context.commentPos(child), false, false);
+            else
+                shouldEmitInterveningComments = mayEmitInterveningComments;
+            this.nextListElementPos = child.pos;
+            this.emitListItem(item, child);
+            if (shouldDecreaseIndentAfterEmit) {
+                this.writer.indent--;
+                shouldDecreaseIndentAfterEmit = false;
+            }
+            previous = child;
+        }
+        const skipTrailingComments = this.commentsDisabled || (previous !== undefined && this.hasEmitFlag(previous, 256 /* EmitFlags.NoTrailingComments */));
+        const emitTrailingComma = hasTrailingComma && (format & 64 /* ListFormat.AllowTrailingComma */) !== 0 && (format & 16 /* ListFormat.CommaDelimited */) !== 0;
+        if (emitTrailingComma) {
+            if (previous !== undefined && !skipTrailingComments)
+                this.emitToken(27 /* SyntaxKind.CommaToken */, previous.end, previous);
+            else
+                this.write1(',');
+        }
+        if (previous !== undefined &&
+            parentEnd !== previous.end &&
+            (format & 60 /* ListFormat.DelimitersMask */) !== 0 &&
+            !skipTrailingComments)
+            this.emitLeadingComments(emitTrailingComma && childrenEnd > 0 ? childrenEnd : previous.end, false);
+        if ((format & 128 /* ListFormat.Indented */) !== 0)
+            this.writer.indent--;
+        const closing = this.getClosingLineTerminatorCount(parent, end > start ? nodes[end - 1] : undefined, format, childrenEnd);
+        if (closing > 0)
+            this.lines(closing);
+        else if ((format & (2097152 /* ListFormat.SpaceAfterList */ | 256 /* ListFormat.SpaceBetweenBraces */)) !== 0)
+            this.space();
+        return childrenPos >= -1;
+    }
+    // Any node
+    emitAnyNode(node) {
+        switch (node.kind) {
+            case 15 /* SyntaxKind.TemplateHead */:
+            case 16 /* SyntaxKind.TemplateMiddle */:
+            case 17 /* SyntaxKind.TemplateTail */:
+                return this.emitLiteral(node);
+            case 79 /* SyntaxKind.Identifier */:
+                if (node instanceof Identifier)
+                    return this.emitIdentifierName(node);
+                break;
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+                if (node instanceof PrivateIdentifier)
+                    return this.emitPrivateIdentifier(node);
+                break;
+            case 167 /* SyntaxKind.QualifiedName */:
+                if (node instanceof QualifiedName)
+                    return this.emitQualifiedName(node);
+                break;
+            case 168 /* SyntaxKind.ComputedPropertyName */:
+                if (node instanceof ComputedPropertyName)
+                    return this.emitComputedPropertyName(node);
+                break;
+            case 169 /* SyntaxKind.TypeParameter */:
+                if (node instanceof TypeParameterDeclaration)
+                    return this.emitTypeParameter(node);
+                break;
+            case 170 /* SyntaxKind.Parameter */:
+                if (node instanceof ParameterDeclaration)
+                    return this.emitParameter(node);
+                break;
+            case 171 /* SyntaxKind.Decorator */:
+                if (node instanceof Decorator)
+                    return this.emitDecorator(node);
+                break;
+            case 172 /* SyntaxKind.PropertySignature */:
+            case 174 /* SyntaxKind.MethodSignature */:
+            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.ConstructSignature */:
+            case 350 /* SyntaxKind.NotEmittedTypeElement */:
+                return this.emitTypeElement(node);
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+            case 182 /* SyntaxKind.IndexSignature */:
+            case 241 /* SyntaxKind.SemicolonClassElement */:
+                return this.emitClassElement(node);
+            case 207 /* SyntaxKind.ObjectBindingPattern */:
+            case 208 /* SyntaxKind.ArrayBindingPattern */:
+                if (node instanceof BindingPattern)
+                    return this.emitBindingPattern(node);
+                break;
+            case 209 /* SyntaxKind.BindingElement */:
+                if (node instanceof BindingElement)
+                    return this.emitBindingElement(node);
+                break;
+            case 240 /* SyntaxKind.TemplateSpan */:
+                return this.emitListItem(14 /* ListItem.TemplateSpan */, node);
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                if (node instanceof VariableDeclaration)
+                    return this.emitVariableDeclaration(node);
+                break;
+            case 262 /* SyntaxKind.VariableDeclarationList */:
+                if (node instanceof VariableDeclarationList)
+                    return this.emitVariableDeclarationList(node);
+                break;
+            case 269 /* SyntaxKind.ModuleBlock */:
+                if (node instanceof ModuleBlock)
+                    return this.emitBlockLike(node, node.statements, false);
+                break;
+            case 270 /* SyntaxKind.CaseBlock */:
+                if (node instanceof CaseBlock)
+                    return this.emitBlockLike(node, node.clauses, true);
+                break;
+            case 274 /* SyntaxKind.ImportClause */:
+                if (node instanceof ImportClause)
+                    return this.emitImportClause(node);
+                break;
+            case 277 /* SyntaxKind.ImportSpecifier */:
+                return this.emitListItem(20 /* ListItem.ImportSpecifier */, node);
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                return this.emitListItem(21 /* ListItem.ExportSpecifier */, node);
+            case 301 /* SyntaxKind.ImportAttributes */:
+                if (node instanceof ImportAttributes)
+                    return this.emitImportAttributes(node);
+                break;
+            case 302 /* SyntaxKind.ImportAttribute */:
+                if (node instanceof ImportAttribute)
+                    return this.emitImportAttribute(node);
+                break;
+            case 11 /* SyntaxKind.JsxText */:
+            case 295 /* SyntaxKind.JsxExpression */:
+                return this.emitJsxChild(node);
+            case 287 /* SyntaxKind.JsxOpeningElement */:
+                if (node instanceof JsxOpeningElement)
+                    return this.emitJsxOpeningElement(node);
+                break;
+            case 288 /* SyntaxKind.JsxClosingElement */:
+                if (node instanceof JsxClosingElement)
+                    return this.emitJsxClosingElement(node);
+                break;
+            case 292 /* SyntaxKind.JsxAttribute */:
+            case 294 /* SyntaxKind.JsxSpreadAttribute */:
+                return this.emitListItem(24 /* ListItem.JsxAttributeLike */, node);
+            case 293 /* SyntaxKind.JsxAttributes */:
+                if (node instanceof JsxAttributes)
+                    return this.emitJsxAttributes(node);
+                break;
+            case 296 /* SyntaxKind.JsxNamespacedName */:
+                return this.emitJsxName(node);
+            case 297 /* SyntaxKind.CaseClause */:
+            case 298 /* SyntaxKind.DefaultClause */:
+                if (node instanceof CaseOrDefaultClause)
+                    return this.emitCaseOrDefaultClause(node);
+                break;
+            case 299 /* SyntaxKind.HeritageClause */:
+                if (node instanceof HeritageClause)
+                    return this.emitHeritageClause(node);
+                break;
+            case 300 /* SyntaxKind.CatchClause */:
+                if (node instanceof CatchClause)
+                    return this.emitCatchClause(node);
+                break;
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 305 /* SyntaxKind.SpreadAssignment */:
+                return this.emitObjectLiteralElement(node);
+            case 306 /* SyntaxKind.EnumMember */:
+                if (node instanceof EnumMember)
+                    return this.emitEnumMember(node);
+                break;
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile)
+                    return this.emitSourceFileNode(node);
+                break;
+        }
+        if (isTypeNodeKind(node.kind))
+            return this.emitTypeNodeOutsideExtends(node);
+        if (isStatement(node))
+            return this.emitStatement(node);
+        if (isExpression(node))
+            return this.emitExpression(node, 0 /* OperatorPrecedence.Lowest */);
+        if (isKeywordKind(node.kind) || isPunctuationKind(node.kind))
+            return this.emitTokenNode(node);
+        if (isJSDocKind(node.kind))
+            throw new Error('Printing JSDoc is not implemented');
+        throw new Error('Unexpected node ' + node.kind);
+    }
+    // Comments
+    emitCommentsBeforeNode(node) {
+        if (!this.shouldEmitComments(node))
+            return false;
+        const flags = this.context.getEmitFlags(node);
+        const pos = this.context.commentPos(node);
+        const end = this.context.commentEnd(node);
+        this.commentStack.push(flags, pos, end, this.containerPos, this.containerEnd, this.declarationListContainerEnd);
+        this.emitLeadingCommentsOfNode(node, flags, pos, end);
+        if ((flags & 128 /* EmitFlags.NoLeadingComments */) === 0) {
+            const synthesized = this.context.getSyntheticLeadingComments(node);
+            if (synthesized !== undefined)
+                for (const comment of synthesized)
+                    this.emitLeadingSynthesizedComment(comment);
+        }
+        if ((flags & 512 /* EmitFlags.NoNestedComments */) !== 0)
+            this.commentsDisabled = true;
+        return true;
+    }
+    emitCommentsAfterNode(node) {
+        const stack = this.commentStack;
+        const base = stack.length - 6;
+        // `| 0` keeps scriptc from typing array reads as possibly undefined.
+        const flags = stack[base] | 0;
+        const pos = stack[base + 1] | 0;
+        const end = stack[base + 2] | 0;
+        const containerPos = stack[base + 3] | 0;
+        const containerEnd = stack[base + 4] | 0;
+        const declarationListContainerEnd = stack[base + 5] | 0;
+        stack.length = base;
+        if ((flags & 512 /* EmitFlags.NoNestedComments */) !== 0)
+            this.commentsDisabled = false;
+        if ((flags & 256 /* EmitFlags.NoTrailingComments */) === 0) {
+            const synthesized = this.context.getSyntheticTrailingComments(node);
+            if (synthesized !== undefined)
+                for (const comment of synthesized)
+                    this.emitTrailingSynthesizedComment(comment);
+        }
+        this.emitTrailingCommentsOfNode(node, flags, pos, end, containerPos, containerEnd, declarationListContainerEnd);
+        // Comments after an erased type annotation.
+        const typeNode = this.context.getTypeNode(node);
+        if (typeNode !== undefined)
+            this.emitTrailingCommentsOfNode(node, flags, typeNode.pos, typeNode.end, containerPos, containerEnd, declarationListContainerEnd);
+        return true;
+    }
+    /** Emits comments before a token; returns whether `emitCommentsAfterToken` applies, with the token's position in `tokenPos`. */
+    emitCommentsBeforeToken(pos, contextNode, flags) {
+        if ((flags & 1 /* TokenEmitFlags.NoComments */) !== 0 || this.commentsDisabled) {
+            this.tokenPos = this.currentSourceFile !== undefined && pos >= 0 ? skipTrivia(this.sourceText, pos) : pos;
+            return false;
+        }
+        const startPos = pos;
+        if (this.currentSourceFile !== undefined)
+            pos = skipTrivia(this.sourceText, startPos);
+        this.tokenPos = pos;
+        const parseNode = this.context.parseNode(contextNode);
+        if (parseNode === undefined || parseNode.kind !== contextNode.kind)
+            return false;
+        if (contextNode.pos !== startPos) {
+            const needsIndent = (flags & 2 /* TokenEmitFlags.IndentLeadingComments */) !== 0 &&
+                this.currentSourceFile !== undefined &&
+                !this.positionsAreOnSameLine(startPos, pos);
+            this.indentIf(needsIndent, 1);
+            this.emitLeadingComments(startPos, false);
+            this.indentIf(needsIndent, -1);
+        }
+        return true;
+    }
+    emitCommentsAfterToken(pos, contextNode) {
+        if (contextNode.end !== pos)
+            this.emitTrailingComments(pos, contextNode.kind === 295 /* SyntaxKind.JsxExpression */ ? 0 /* CommentSeparator.None */ : 1 /* CommentSeparator.Before */);
+        return true;
+    }
+    emitDetachedCommentsBeforeStatementList(node, pos) {
+        if (node instanceof SourceFile) {
+            const statements = node.statements.nodes;
+            if (statements.length > 0 && isPrologueDirective(statements[0]) && !nodeIsSynthesized(statements[0]))
+                return -1;
+        }
+        const flags = this.context.getEmitFlags(node);
+        if (!positionIsSynthesized(pos) && (flags & 128 /* EmitFlags.NoLeadingComments */) === 0)
+            this.emitDetachedCommentsAndUpdateCommentsInfo(pos);
+        if ((flags & 512 /* EmitFlags.NoNestedComments */) !== 0)
+            this.commentsDisabled = true;
+        return flags;
+    }
+    /** `flags` is what `emitDetachedCommentsBeforeStatementList` returned; -1 if it emitted nothing. */
+    emitDetachedCommentsAfterStatementList(node, end, flags) {
+        if (flags < 0)
+            return false;
+        if (this.commentsDisabled || positionIsSynthesized(end) || (flags & 256 /* EmitFlags.NoTrailingComments */) !== 0)
+            return false;
+        if (this.emitLeadingComments(end, false) && !this.writer.isAtStartOfLine())
+            this.line();
+        return node.kind >= 0;
+    }
+    emitLeadingCommentsOfNode(node, flags, pos, end) {
+        if ((positionIsSynthesized(pos) && positionIsSynthesized(end)) || pos === end)
+            return false;
+        const jsxText = node.kind === 11 /* SyntaxKind.JsxText */;
+        const skipLeading = positionIsSynthesized(pos) || (flags & 128 /* EmitFlags.NoLeadingComments */) !== 0 || jsxText;
+        const skipTrailing = positionIsSynthesized(end) || (flags & 256 /* EmitFlags.NoTrailingComments */) !== 0 || jsxText;
+        if (!skipLeading)
+            this.emitLeadingComments(pos, node.kind === 347 /* SyntaxKind.NotEmittedStatement */);
+        if (!skipLeading || (pos >= 0 && (flags & 128 /* EmitFlags.NoLeadingComments */) !== 0))
+            this.containerPos = pos;
+        if (!skipTrailing || (end >= 0 && (flags & 256 /* EmitFlags.NoTrailingComments */) !== 0)) {
+            this.containerEnd = end;
+            if (node.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+                this.declarationListContainerEnd = end;
+        }
+        return true;
+    }
+    emitTrailingCommentsOfNode(node, flags, pos, end, containerPos, containerEnd, declarationListContainerEnd) {
+        const skipTrailing = end < 0 || (flags & 256 /* EmitFlags.NoTrailingComments */) !== 0 || node.kind === 11 /* SyntaxKind.JsxText */;
+        if ((positionIsSynthesized(pos) && positionIsSynthesized(end)) || pos === end)
+            return false;
+        this.containerPos = containerPos;
+        this.containerEnd = containerEnd;
+        this.declarationListContainerEnd = declarationListContainerEnd;
+        if (!skipTrailing && node.kind !== 347 /* SyntaxKind.NotEmittedStatement */)
+            this.emitTrailingComments(end, 1 /* CommentSeparator.Before */);
+        return true;
+    }
+    emitLeadingSynthesizedComment(comment) {
+        if (comment.hasLeadingNewLine || comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */)
+            this.line();
+        this.writeSynthesizedComment(comment);
+        if (comment.hasTrailingNewLine || comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */)
+            this.line();
+        else
+            this.space();
+        return true;
+    }
+    emitTrailingSynthesizedComment(comment) {
+        if (!this.writer.isAtStartOfLine())
+            this.space();
+        this.writeSynthesizedComment(comment);
+        if (comment.hasTrailingNewLine)
+            this.line();
+        return true;
+    }
+    writeSynthesizedComment(comment) {
+        const multiLine = comment.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */;
+        const text = multiLine ? '/*' + comment.text + '*/' : '//' + comment.text;
+        return this.writeCommentText(text, multiLine ? computeLineStarts(text) : [0], comment.kind, 0, text.length);
+    }
+    emitLeadingComments(pos, elided) {
+        if (this.commentsDisabled || this.currentSourceFile === undefined || pos < 0 || pos === this.containerPos)
+            return false;
+        // 1: only triple-slash comments, 2: all but triple-slash comments, 0: all.
+        let tripleSlash = 0;
+        if (!elided) {
+            if (pos === 0 && this.currentSourceFile.isDeclarationFile)
+                tripleSlash = 2;
+        }
+        else if (pos === 0)
+            tripleSlash = 1;
+        else
+            return false;
+        const detached = this.detachedComments;
+        if (detached.length > 0 && detached[detached.length - 2] === pos) {
+            pos = detached[detached.length - 1] | 0;
+            detached.pop();
+            detached.pop();
+        }
+        const ranges = getLeadingCommentRanges(this.sourceText, pos);
+        if (ranges === undefined)
+            return false;
+        let comments = undefined;
+        for (const comment of ranges) {
+            if (!this.shouldWriteComment(comment))
+                continue;
+            if (tripleSlash !== 0 && isRecognizedTripleSlashComment(this.sourceText, comment) !== (tripleSlash === 1))
+                continue;
+            if (comments === undefined)
+                comments = [];
+            comments.push(comment);
+        }
+        if (comments === undefined)
+            return false;
+        if (this.shouldEmitNewLineBeforeLeadingComment(pos, comments[0].pos))
+            this.line();
+        return this.emitComments(comments, 2 /* CommentSeparator.After */);
+    }
+    shouldEmitNewLineBeforeLeadingComment(pos, commentPos) {
+        return (this.currentSourceFile !== undefined &&
+            pos !== commentPos &&
+            computeLineOfPosition(this.lineStarts, pos) !== computeLineOfPosition(this.lineStarts, commentPos));
+    }
+    emitLeadingCommentsOfPosition(pos) {
+        if (this.commentsDisabled || pos === -1)
+            return false;
+        return this.emitLeadingComments(pos, false);
+    }
+    emitTrailingComments(pos, separator) {
+        if (this.commentsDisabled ||
+            this.currentSourceFile === undefined ||
+            (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd)))
+            return false;
+        const ranges = getTrailingCommentRanges(this.sourceText, pos);
+        if (ranges === undefined)
+            return false;
+        let comments = undefined;
+        for (const comment of ranges) {
+            if (!this.shouldWriteComment(comment))
+                continue;
+            if (comments === undefined)
+                comments = [];
+            comments.push(comment);
+        }
+        return comments !== undefined && this.emitComments(comments, separator);
+    }
+    emitTrailingCommentsOfPosition(pos, prefixSpace, forceNoNewline) {
+        if (this.commentsDisabled || this.currentSourceFile === undefined)
+            return false;
+        if (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd))
+            return false;
+        const comments = getTrailingCommentRanges(this.sourceText, pos);
+        if (comments === undefined)
+            return false;
+        for (const comment of comments) {
+            if (prefixSpace) {
+                if (!this.shouldWriteComment(comment))
+                    continue;
+                if (!this.writer.isAtStartOfLine())
+                    this.space();
+                this.emitComment(comment);
+                if (comment.hasTrailingNewLine)
+                    this.line();
+                continue;
+            }
+            this.emitComment(comment);
+            if (forceNoNewline) {
+                if (comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */)
+                    this.line();
+            }
+            else if (comment.hasTrailingNewLine)
+                this.line();
+            else
+                this.space();
+        }
+        return true;
+    }
+    emitDetachedCommentsAndUpdateCommentsInfo(pos) {
+        if (this.currentSourceFile === undefined)
+            return false;
+        const end = this.emitDetachedComments(pos);
+        if (end < 0)
+            return false;
+        this.detachedComments.push(pos, end);
+        return true;
+    }
+    /** Emits a leading copyright-style comment block; returns its end, or -1 if there is none. */
+    emitDetachedComments(pos) {
+        const text = this.sourceText;
+        let leading;
+        if (this.commentsDisabled) {
+            // Without comments, keep pinned comments at the top of the file.
+            if (pos === 0) {
+                const ranges = getLeadingCommentRanges(text, pos);
+                if (ranges !== undefined)
+                    for (const range of ranges)
+                        if (isPinnedComment(text, range)) {
+                            if (leading === undefined)
+                                leading = [];
+                            leading.push(range);
+                        }
+            }
+        }
+        else
+            leading = getLeadingCommentRanges(text, pos);
+        if (leading === undefined || leading.length === 0)
+            return -1;
+        const lineStarts = this.lineStarts;
+        let count = 0;
+        for (let i = 0; i < leading.length; i++) {
+            if (i > 0) {
+                const lastLine = computeLineOfPosition(lineStarts, leading[i - 1].end);
+                const line = computeLineOfPosition(lineStarts, leading[i].pos);
+                // A blank line ends the block.
+                if (line >= lastLine + 2)
+                    break;
+            }
+            count++;
+        }
+        const lastEnd = leading[count - 1].end;
+        const lastLine = computeLineOfPosition(lineStarts, lastEnd);
+        const nodeLine = computeLineOfPosition(lineStarts, skipTrivia(text, pos));
+        if (nodeLine < lastLine + 2)
+            return -1;
+        let toEmit = undefined;
+        for (let i = 0; i < count; i++) {
+            const comment = leading[i];
+            if (!this.shouldWriteComment(comment))
+                continue;
+            if (toEmit === undefined)
+                toEmit = [];
+            toEmit.push(comment);
+        }
+        if (toEmit !== undefined) {
+            if (this.shouldEmitNewLineBeforeLeadingComment(pos, toEmit[0].pos))
+                this.line();
+            this.emitComments(toEmit, 2 /* CommentSeparator.After */);
+        }
+        return lastEnd;
+    }
+    emitComments(comments, separator) {
+        if (comments.length === 0)
+            return false;
+        let interveningSeparator = false;
+        if (separator === 1 /* CommentSeparator.Before */)
+            this.space();
+        for (const comment of comments) {
+            if (interveningSeparator) {
+                this.space();
+                interveningSeparator = false;
+            }
+            this.emitComment(comment);
+            if (comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ ||
+                (comment.hasTrailingNewLine && separator !== 0 /* CommentSeparator.None */))
+                this.line();
+            else
+                interveningSeparator = separator !== 0 /* CommentSeparator.None */;
+        }
+        if (interveningSeparator && separator === 2 /* CommentSeparator.After */)
+            this.space();
+        return true;
+    }
+    emitComment(comment) {
+        this.emitPos(comment.pos);
+        this.writeCommentRange(comment);
+        return this.emitPos(comment.end);
+    }
+    // Source maps
+    setSourceMapSource(source) {
+        if (this.sourceMapsDisabled)
+            return false;
+        this.sourceMapSource = source;
+        this.sourceMapLineStarts = source.lineStarts();
+        this.sourceMapLine = 0;
+        if (this.mostRecentSourceMapSource === source) {
+            this.sourceMapSourceIndex = this.mostRecentSourceMapSourceIndex;
+            return true;
+        }
+        this.sourceMapSourceIsJson = fileExtensionIs(source.fileName, '.json');
+        if (this.sourceMapSourceIsJson)
+            return true;
+        const generator = this.sourceMapGenerator;
+        this.sourceMapSourceIndex = generator.addSource(source.fileName);
+        if (this.options.inlineSources)
+            generator.setSourceContent(this.sourceMapSourceIndex, source.text);
+        this.mostRecentSourceMapSource = source;
+        this.mostRecentSourceMapSourceIndex = this.sourceMapSourceIndex;
+        return true;
+    }
+    emitPos(pos) {
+        const generator = this.sourceMapGenerator;
+        if (this.sourceMapsDisabled ||
+            this.sourceMapSource === undefined ||
+            generator === undefined ||
+            this.sourceMapSourceIsJson ||
+            pos < 0)
+            return false;
+        const lineStarts = this.sourceMapLineStarts;
+        const line = this.sourceMapLineOf(pos);
+        return generator.addSourceMapping(this.writer.getLine(), this.writer.getColumn(), this.sourceMapSourceIndex, line, pos - (lineStarts[line] | 0));
+    }
+    /**
+     * The line of `pos` in the source map source, as `computeLineOfPosition` finds it. Positions mostly
+     * increase, so the line of the last position and the few after it are tried first.
+     */
+    sourceMapLineOf(pos) {
+        const lineStarts = this.sourceMapLineStarts;
+        let line = this.sourceMapLine;
+        if (line < lineStarts.length && (lineStarts[line] | 0) <= pos) {
+            for (let k = 0; k < 4; k++) {
+                if (line + 1 >= lineStarts.length || (lineStarts[line + 1] | 0) > pos) {
+                    this.sourceMapLine = line;
+                    return line;
+                }
+                line++;
+            }
+        }
+        line = computeLineOfPosition(lineStarts, pos);
+        this.sourceMapLine = line;
+        return line;
+    }
+    emitSourceMapsBeforeNode(node) {
+        if (!this.shouldEmitSourceMaps(node))
+            return false;
+        const flags = this.context.getEmitFlags(node);
+        const pos = this.context.sourceMapPos(node);
+        const end = this.context.sourceMapEnd(node);
+        if (node.kind !== 347 /* SyntaxKind.NotEmittedStatement */ &&
+            (flags & 4 /* EmitFlags.NoLeadingSourceMap */) === 0 &&
+            this.currentSourceFile !== undefined &&
+            pos >= 0)
+            this.emitPos(skipTrivia(this.sourceText, pos));
+        if ((flags & 16 /* EmitFlags.NoNestedSourceMaps */) !== 0)
+            this.sourceMapsDisabled = true;
+        this.sourceMapStack.push(flags, pos, end, 0);
+        return true;
+    }
+    emitSourceMapsAfterNode(node) {
+        const stack = this.sourceMapStack;
+        const base = stack.length - 4;
+        const flags = stack[base] | 0;
+        const end = stack[base + 2] | 0;
+        stack.length = base;
+        if ((flags & 16 /* EmitFlags.NoNestedSourceMaps */) !== 0)
+            this.sourceMapsDisabled = false;
+        if (node.kind !== 347 /* SyntaxKind.NotEmittedStatement */ && (flags & 8 /* EmitFlags.NoTrailingSourceMap */) === 0 && end >= 0)
+            this.emitPos(end);
+        return true;
+    }
+    emitSourceMapsBeforeToken(token, pos, contextNode, flags) {
+        if ((flags & 4 /* TokenEmitFlags.NoSourceMaps */) !== 0 ||
+            !this.shouldEmitSourceMaps(contextNode) ||
+            this.options.omitBraceSourceMapPositions ||
+            (token !== 18 /* SyntaxKind.OpenBraceToken */ && token !== 19 /* SyntaxKind.CloseBraceToken */))
+            return false;
+        const emitFlags = this.context.getEmitFlags(contextNode);
+        const range = this.context.tokenSourceMapRange(contextNode, token);
+        if (range !== undefined)
+            pos = range[0] | 0;
+        if (pos >= 0 && this.currentSourceFile !== undefined)
+            pos = skipTrivia(this.sourceText, pos);
+        if ((emitFlags & 32 /* EmitFlags.NoTokenLeadingSourceMaps */) === 0 && pos >= 0)
+            this.emitPos(pos);
+        this.sourceMapStack.push(emitFlags, range === undefined ? -1 : range[0] | 0, range === undefined ? -1 : range[1] | 0, range === undefined ? 0 : 1);
+        return true;
+    }
+    emitSourceMapsAfterToken(pos) {
+        const stack = this.sourceMapStack;
+        const base = stack.length - 4;
+        const flags = stack[base] | 0;
+        const end = stack[base + 2] | 0;
+        const hasRange = stack[base + 3] !== 0;
+        stack.length = base;
+        if ((flags & 64 /* EmitFlags.NoTokenTrailingSourceMaps */) === 0) {
+            if (hasRange)
+                pos = end;
+            if (pos >= 0)
+                this.emitPos(pos);
+        }
+        return true;
+    }
+    // Name generation
+    pushNameGenerationScope(node) {
+        return this.nameGenerator.pushScope(this.hasEmitFlag(node, 32768 /* EmitFlags.ReuseTempVariableScope */));
+    }
+    popNameGenerationScope(node) {
+        return this.nameGenerator.popScope(this.hasEmitFlag(node, 32768 /* EmitFlags.ReuseTempVariableScope */));
+    }
+    generateAllNames(nodes) {
+        if (nodes === undefined)
+            return false;
+        for (const node of nodes.nodes)
+            this.generateNames(node);
+        return true;
+    }
+    generateNames(node) {
+        if (node === undefined)
+            return false;
+        // Only generated names need work; parse trees without them are common.
+        if (this.context.autoGenerate.size === 0)
+            return false;
+        if (node instanceof Block)
+            return this.generateAllNames(node.statements);
+        if (node instanceof CaseOrDefaultClause)
+            return this.generateAllNames(node.statements);
+        if (node instanceof LabeledStatement)
+            return this.generateNames(node.statement);
+        if (node instanceof WithStatement)
+            return this.generateNames(node.statement);
+        if (node instanceof DoStatement)
+            return this.generateNames(node.statement);
+        if (node instanceof WhileStatement)
+            return this.generateNames(node.statement);
+        if (node instanceof IfStatement) {
+            this.generateNames(node.thenStatement);
+            return this.generateNames(node.elseStatement);
+        }
+        if (node instanceof ForStatement) {
+            this.generateNames(node.initializer);
+            return this.generateNames(node.statement);
+        }
+        if (node instanceof ForInOrOfStatement) {
+            this.generateNames(node.initializer);
+            return this.generateNames(node.statement);
+        }
+        if (node instanceof SwitchStatement)
+            return this.generateNames(node.caseBlock);
+        if (node instanceof CaseBlock)
+            return this.generateAllNames(node.clauses);
+        if (node instanceof TryStatement) {
+            this.generateNames(node.tryBlock);
+            this.generateNames(node.catchClause);
+            return this.generateNames(node.finallyBlock);
+        }
+        if (node instanceof CatchClause) {
+            this.generateNames(node.variableDeclaration);
+            return this.generateNames(node.block);
+        }
+        if (node instanceof VariableStatement)
+            return this.generateNames(node.declarationList);
+        if (node instanceof VariableDeclarationList)
+            return this.generateAllNames(node.declarations);
+        if (node instanceof VariableDeclaration)
+            return this.generateNameIfNeeded(node.name);
+        if (node instanceof ParameterDeclaration)
+            return this.generateNameIfNeeded(node.name);
+        if (node instanceof BindingElement)
+            return this.generateNameIfNeeded(node.name);
+        if (node instanceof ClassDeclaration)
+            return this.generateNameIfNeeded(node.name);
+        if (node instanceof FunctionDeclaration) {
+            this.generateNameIfNeeded(node.name);
+            if (this.hasEmitFlag(node, 32768 /* EmitFlags.ReuseTempVariableScope */)) {
+                this.generateAllNames(node.parameters);
+                this.generateNames(node.body);
+            }
+            return true;
+        }
+        if (node instanceof BindingPattern)
+            return this.generateAllNames(node.elements);
+        if (node instanceof ImportDeclaration)
+            return this.generateNames(node.importClause);
+        if (node instanceof ImportClause) {
+            this.generateNameIfNeeded(node.name);
+            return this.generateNames(node.namedBindings);
+        }
+        if (node instanceof NamespaceImport)
+            return this.generateNameIfNeeded(node.name);
+        if (node instanceof NamespaceExport)
+            return this.generateNameIfNeeded(node.name);
+        if (node instanceof NamedImports)
+            return this.generateAllNames(node.elements);
+        if (node instanceof ImportSpecifier)
+            return this.generateNameIfNeeded(node.propertyName !== undefined ? node.propertyName : node.name);
+        return false;
+    }
+    generateAllMemberNames(nodes) {
+        if (nodes === undefined || this.context.autoGenerate.size === 0)
+            return false;
+        for (const node of nodes.nodes) {
+            switch (node.kind) {
+                case 303 /* SyntaxKind.PropertyAssignment */:
+                case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                case 173 /* SyntaxKind.PropertyDeclaration */:
+                case 172 /* SyntaxKind.PropertySignature */:
+                case 175 /* SyntaxKind.MethodDeclaration */:
+                case 174 /* SyntaxKind.MethodSignature */:
+                case 178 /* SyntaxKind.GetAccessor */:
+                case 179 /* SyntaxKind.SetAccessor */:
+                    this.generateNameIfNeeded(getName(node));
+            }
+        }
+        return true;
+    }
+    generateNameIfNeeded(name) {
+        if (name === undefined || this.context.autoGenerate.size === 0)
+            return false;
+        if (isMemberName(name)) {
+            this.nameGenerator.generateName(name);
+            return true;
+        }
+        if (name instanceof BindingPattern)
+            return this.generateNames(name);
+        return false;
+    }
+    // Scopes
+    enterNode(node) {
+        let state = 0 /* State.None */;
+        if (this.emitCommentsBeforeNode(node))
+            state |= 1 /* State.Comments */;
+        if (this.emitSourceMapsBeforeNode(node))
+            state |= 2 /* State.SourceMaps */;
+        return state;
+    }
+    exitNode(node, state) {
+        if ((state & 2 /* State.SourceMaps */) !== 0)
+            this.emitSourceMapsAfterNode(node);
+        if ((state & 1 /* State.Comments */) !== 0)
+            this.emitCommentsAfterNode(node);
+        return true;
+    }
+    enterTokenNode(node, flags) {
+        let state = 0 /* State.None */;
+        if ((flags & 1 /* TokenEmitFlags.NoComments */) === 0 && this.emitCommentsBeforeNode(node))
+            state |= 1 /* State.Comments */;
+        if ((flags & 4 /* TokenEmitFlags.NoSourceMaps */) === 0 && this.emitSourceMapsBeforeNode(node))
+            state |= 2 /* State.SourceMaps */;
+        return state;
+    }
+    exitTokenNode(node, state) {
+        return this.exitNode(node, state);
+    }
+    enterToken(token, pos, contextNode, flags) {
+        let state = 0 /* State.None */;
+        if (this.emitCommentsBeforeToken(pos, contextNode, flags))
+            state |= 1 /* State.Comments */;
+        if (this.emitSourceMapsBeforeToken(token, this.tokenPos, contextNode, flags))
+            state |= 2 /* State.SourceMaps */;
+        return state;
+    }
+    exitToken(token, pos, contextNode, state) {
+        if ((state & 2 /* State.SourceMaps */) !== 0)
+            this.emitSourceMapsAfterToken(pos);
+        if ((state & 1 /* State.Comments */) !== 0)
+            this.emitCommentsAfterToken(pos, contextNode);
+        return token >= 0;
+    }
+}
+function openingBracket(format) {
+    switch (format & 15360 /* ListFormat.BracketsMask */) {
+        case 1024 /* ListFormat.Braces */:
+            return '{';
+        case 2048 /* ListFormat.Parenthesis */:
+            return '(';
+        case 4096 /* ListFormat.AngleBrackets */:
+            return '<';
+    }
+    return '[';
+}
+function closingBracket(format) {
+    switch (format & 15360 /* ListFormat.BracketsMask */) {
+        case 1024 /* ListFormat.Braces */:
+            return '}';
+        case 2048 /* ListFormat.Parenthesis */:
+            return ')';
+        case 4096 /* ListFormat.AngleBrackets */:
+            return '>';
+    }
+    return ']';
+}
+function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        if (ch === 0x0d || ch === 0x0a) {
+            lines.push(text.substring(start, i));
+            if (ch === 0x0d && i + 1 < text.length && text.charCodeAt(i + 1) === 0x0a)
+                i++;
+            start = i + 1;
+        }
+    }
+    if (start < text.length)
+        lines.push(text.substring(start));
+    return lines;
+}
+/** The smallest leading whitespace of the non-blank lines. */
+function guessIndentation(lines) {
+    let indentation = 0x7fffffff;
+    for (const line of lines) {
+        if (line.length === 0)
+            continue;
+        let i = 0;
+        while (i < line.length && i < indentation) {
+            const ch = line.charCodeAt(i);
+            if (!isWhiteSpaceLike(ch))
+                break;
+            i++;
+        }
+        if (i < indentation)
+            indentation = i;
+        if (indentation === 0)
+            return 0;
+    }
+    return indentation === 0x7fffffff ? 0 : indentation;
+}
+/** The list holding `node` in its parent, for comparing sibling positions. */
+function getContainingNodeArray(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return undefined;
+    switch (node.kind) {
+        case 169 /* SyntaxKind.TypeParameter */:
+            return getTypeParameters(parent);
+        case 170 /* SyntaxKind.Parameter */:
+            return getParameters(parent);
+        case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+            return parent instanceof TemplateLiteralTypeNode ? parent.templateSpans : undefined;
+        case 240 /* SyntaxKind.TemplateSpan */:
+            return parent instanceof TemplateExpression ? parent.templateSpans : undefined;
+        case 171 /* SyntaxKind.Decorator */:
+            return getModifiers(parent);
+        case 299 /* SyntaxKind.HeritageClause */:
+            if (parent instanceof ClassDeclaration)
+                return parent.heritageClauses;
+            if (parent instanceof ClassExpression)
+                return parent.heritageClauses;
+            if (parent instanceof InterfaceDeclaration)
+                return parent.heritageClauses;
+            return undefined;
+    }
+    switch (parent.kind) {
+        case 188 /* SyntaxKind.TypeLiteral */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            if (parent instanceof TypeLiteralNode)
+                return parent.members;
+            if (parent instanceof InterfaceDeclaration)
+                return parent.members;
+            if (parent instanceof ClassDeclaration)
+                return parent.members;
+            if (parent instanceof ClassExpression)
+                return parent.members;
+            if (parent instanceof EnumDeclaration)
+                return parent.members;
+            break;
+        case 193 /* SyntaxKind.UnionType */:
+            if (parent instanceof UnionTypeNode)
+                return parent.types;
+            break;
+        case 194 /* SyntaxKind.IntersectionType */:
+            if (parent instanceof IntersectionTypeNode)
+                return parent.types;
+            break;
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 190 /* SyntaxKind.TupleType */:
+        case 276 /* SyntaxKind.NamedImports */:
+        case 280 /* SyntaxKind.NamedExports */:
+            return getElements(parent);
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 293 /* SyntaxKind.JsxAttributes */:
+            return getProperties(parent);
+        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+            if (isTypeNodeKind(node.kind))
+                return getTypeArguments(parent);
+            if (parent instanceof CallExpression && node !== parent.expression)
+                return parent.arguments;
+            if (parent instanceof NewExpression && node !== parent.expression)
+                return parent.arguments;
+            break;
+        case 285 /* SyntaxKind.JsxElement */:
+            if (parent instanceof JsxElement)
+                return parent.children;
+            break;
+        case 289 /* SyntaxKind.JsxFragment */:
+            if (parent instanceof JsxFragment)
+                return parent.children;
+            break;
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            if (isTypeNodeKind(node.kind))
+                return getTypeArguments(parent);
+            break;
+        case 242 /* SyntaxKind.Block */:
+        case 269 /* SyntaxKind.ModuleBlock */:
+        case 297 /* SyntaxKind.CaseClause */:
+        case 298 /* SyntaxKind.DefaultClause */:
+        case 307 /* SyntaxKind.SourceFile */:
+            return getStatements(parent);
+        case 270 /* SyntaxKind.CaseBlock */:
+            if (parent instanceof CaseBlock)
+                return parent.clauses;
+            break;
+    }
+    if (isModifier(node))
+        return getModifiers(parent);
+    return undefined;
+}