tsc-ts 0.0.9 → 0.1.0

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

@@ -39,6 +39,8 @@ export class PrinterOptions {
         this.terminateUnterminatedLiterals = false;
     }
 }
+/** The saved emit flags of a node whose comments were not looked for (`Printer.inCommentFreeRange`). */
+const commentFreeNode = -1;
 export class Printer extends NameGeneratorHost {
     options;
     context;
@@ -50,6 +52,13 @@ export class Printer extends NameGeneratorHost {
     currentSourceFile;
     sourceText;
     lineStarts;
+    /**
+     * The line of the last `lineOf` lookup, `lookupLine`, and the positions it spans, `[lookupLineStart, lookupLineEnd)`,
+     * with `lookupLineEnd` -1 after the last line: printing reads positions mostly in order, so most lookups fall on that line.
+     */
+    lookupLine;
+    lookupLineStart;
+    lookupLineEnd;
     writer;
     ownWriter;
     uniqueHelperNames;
@@ -63,8 +72,25 @@ export class Printer extends NameGeneratorHost {
     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. */
+    /**
+     * Saved comment state, 32-bit values: emit flags, comment pos, comment end, container pos, container end,
+     * declaration list end.
+     * Flags are `commentFreeNode` for a node that `emitCommentsBeforeNode` handled in a comment-free range.
+     */
     commentStack;
+    /** The used length of `commentStack`: entries are written in place and kept for reuse once popped. */
+    commentDepth;
+    /** Start positions of `//` and `/*` in `sourceText`, ascending; made on first use for each file. */
+    commentStarts;
+    /**
+     * A range of `sourceText`, `[freeStart, freeEnd)`, where no comment starts and the last character is not trivia,
+     * so no comment is found from any position in it; -1 when there is none. `freeOwner` is the node it was made for.
+     */
+    freeStart;
+    freeEnd;
+    /** Whether no trailing comment follows `freeEnd`. */
+    freeEndTrailingNone;
+    freeOwner;
     /** Saved source map state: emit flags, pos, end, has token range. */
     sourceMapStack;
     /** The token position after `enterToken` skipped trivia. */
@@ -94,6 +120,9 @@ export class Printer extends NameGeneratorHost {
         this.currentSourceFile = undefined;
         this.sourceText = '';
         this.lineStarts = [];
+        this.lookupLine = -1;
+        this.lookupLineStart = 0;
+        this.lookupLineEnd = 0;
         this.writer = new TextWriter(options.newLine, 4);
         this.ownWriter = undefined;
         this.uniqueHelperNames = undefined;
@@ -105,7 +134,13 @@ export class Printer extends NameGeneratorHost {
         this.detachedComments = [];
         this.commentsDisabled = options.removeComments;
         this.inExtends = false;
-        this.commentStack = [];
+        this.commentStack = new Int32Array(96);
+        this.commentDepth = 0;
+        this.commentStarts = undefined;
+        this.freeStart = -1;
+        this.freeEnd = -1;
+        this.freeEndTrailingNone = false;
+        this.freeOwner = undefined;
         this.sourceMapStack = [];
         this.tokenPos = 0;
         this.sourceMapsDisabled = true;
@@ -150,6 +185,11 @@ export class Printer extends NameGeneratorHost {
         this.currentSourceFile = sourceFile;
         this.sourceText = sourceFile === undefined ? '' : sourceFile.text;
         this.lineStarts = sourceFile === undefined ? [] : sourceFile.lineStarts();
+        this.lookupLine = -1;
+        this.lookupLineStart = 0;
+        this.lookupLineEnd = 0;
+        this.commentStarts = undefined;
+        this.endCommentFreeRange();
         return true;
     }
     /** Prints `node` into `writer`, adding mappings to `sourceMapGenerator` if given. */
@@ -187,7 +227,8 @@ export class Printer extends NameGeneratorHost {
     // Text of nodes
     isFileLevelUniqueName(name) {
         const file = this.currentSourceFile;
-        return file === undefined || isFileLevelUniqueName(file, name);
+        // The names of the source file as parsed, not as transformed.
+        return file === undefined || isFileLevelUniqueName(this.context.mostOriginal(file), name);
     }
     getLiteralTextOfNode(node, sourceFile, flags) {
         if (node instanceof StringLiteral) {
@@ -233,7 +274,10 @@ export class Printer extends NameGeneratorHost {
         switch (node.kind) {
             case 79 /* SyntaxKind.Identifier */:
             case 80 /* SyntaxKind.PrivateIdentifier */:
-            case 296 /* SyntaxKind.JsxNamespacedName */:
+            case 297 /* SyntaxKind.JsxNamespacedName */:
+                // Its text either way: the source text, or the text of a node from elsewhere.
+                if (this.textIsSourceText(node))
+                    return node.text;
                 if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
                     if (node instanceof Identifier)
                         return node.text;
@@ -256,6 +300,39 @@ export class Printer extends NameGeneratorHost {
         }
         return getSourceTextOfNode(this.sourceText, node);
     }
+    /**
+     * Whether the source text of an identifier or private identifier of the current file, from the end of its leading
+     * trivia to its end, is its text: the text ends the node, and the character before it is not part of the token, as
+     * it would be in an identifier written with escapes. Nodes from JSDoc may span other text, so they are left to the
+     * general path.
+     */
+    textIsSourceText(node) {
+        if (!(node instanceof Identifier) && !(node instanceof PrivateIdentifier))
+            return false;
+        if ((node.flags & (8 /* NodeFlags.Reparsed */ | 4194304 /* NodeFlags.JSDoc */ | 268435456 /* NodeFlags.ReparserTransformedLiteral */)) !== 0)
+            return false;
+        const text = node.text;
+        const source = this.sourceText;
+        const end = node.end;
+        const start = end - text.length;
+        if (text.length === 0 || start < node.pos || end > source.length)
+            return false;
+        if (!source.startsWith(text, start))
+            return false;
+        if (start === node.pos)
+            return true;
+        const before = source.charCodeAt(start - 1);
+        return !((before >= 97 /* CharacterCodes.a */ && before <= 122 /* CharacterCodes.z */) ||
+            (before >= 65 /* CharacterCodes.A */ && before <= 90 /* CharacterCodes.Z */) ||
+            (before >= 48 /* CharacterCodes._0 */ && before <= 57 /* CharacterCodes._9 */) ||
+            before === 95 /* CharacterCodes._ */ ||
+            before === 36 /* CharacterCodes.$ */ ||
+            before === 92 /* CharacterCodes.backslash */ ||
+            before === 123 /* CharacterCodes.openBrace */ ||
+            before === 125 /* CharacterCodes.closeBrace */ ||
+            before === 35 /* CharacterCodes.hash */ ||
+            before > 127 /* CharacterCodes.maxAsciiCharacter */);
+    }
     isInCurrentSourceFile(node) {
         const file = this.currentSourceFile;
         if (file === undefined)
@@ -331,7 +408,28 @@ export class Printer extends NameGeneratorHost {
     }
     // Lines between nodes
     positionsAreOnSameLine(pos1, pos2) {
-        return getLinesBetweenPositions(this.lineStarts, pos1, pos2) === 0;
+        if (pos1 === pos2)
+            return true;
+        const lower = pos1 < pos2 ? pos1 : pos2;
+        const upper = pos1 < pos2 ? pos2 : pos1;
+        // What getLinesBetweenPositions finds: no line starts in (lower, upper].
+        if (lower < 0) {
+            const first = this.lineStarts.length > 0 ? this.lineStarts[0] | 0 : -1;
+            return first < 0 || upper < first;
+        }
+        this.lineOf(lower);
+        return this.lookupLineEnd < 0 || upper < this.lookupLineEnd;
+    }
+    /** The zero-based line of `pos` (-1 before the first line), which becomes the line of the last lookup. */
+    lineOf(pos) {
+        if (pos >= this.lookupLineStart && (pos < this.lookupLineEnd || this.lookupLineEnd < 0) && this.lookupLine >= 0)
+            return this.lookupLine;
+        const starts = this.lineStarts;
+        const line = computeLineOfPosition(starts, pos);
+        this.lookupLine = line;
+        this.lookupLineStart = line >= 0 ? starts[line] | 0 : 0;
+        this.lookupLineEnd = line + 1 < starts.length ? starts[line + 1] | 0 : -1;
+        return line;
     }
     rangeStart(pos) {
         return getStartPositionOfRange(this.sourceText, pos, false);
@@ -517,7 +615,7 @@ export class Printer extends NameGeneratorHost {
     }
     // Emit flags
     shouldEmitComments(node) {
-        return !this.commentsDisabled && this.currentSourceFile !== undefined && node.kind !== 307 /* SyntaxKind.SourceFile */;
+        return !this.commentsDisabled && this.currentSourceFile !== undefined && node.kind !== 308 /* SyntaxKind.SourceFile */;
     }
     shouldWriteComment(comment) {
         return (!this.options.onlyPrintJSDocStyle ||
@@ -561,13 +659,13 @@ export class Printer extends NameGeneratorHost {
     shouldEmitSourceMaps(node) {
         return (!this.sourceMapsDisabled &&
             this.sourceMapSource !== undefined &&
-            node.kind !== 307 /* SyntaxKind.SourceFile */ &&
+            node.kind !== 308 /* 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 */);
+            node.kind === 212 /* SyntaxKind.ObjectLiteralExpression */);
     }
     hasCommentsAtPosition(pos) {
         if (this.currentSourceFile === undefined)
@@ -617,8 +715,13 @@ export class Printer extends NameGeneratorHost {
         return true;
     }
     // Names
-    // Source text of names reparsed from JSDoc can span lines.
+    // Source text of names reparsed from JSDoc can span lines; an identifier's own source text has no line breaks.
     emitIdentifierText(node) {
+        if (!this.context.autoGenerate.has(node) && this.textIsSourceText(node)) {
+            // writeText's answer for text without line breaks.
+            this.writer.write(node.text);
+            return false;
+        }
         return this.writer.writeText(this.getTextOfNode(node));
     }
     emitIdentifierName(node) {
@@ -671,7 +774,10 @@ export class Printer extends NameGeneratorHost {
         const state = this.enterNode(node);
         this.emitEntityName(node.left);
         this.write1('.');
-        this.emitIdentifierName(node.right);
+        if (node.right instanceof PrivateIdentifier)
+            this.emitPrivateIdentifier(node.right);
+        else
+            this.emitIdentifierName(node.right);
         this.exitNode(node, state);
         return true;
     }
@@ -737,7 +843,7 @@ export class Printer extends NameGeneratorHost {
         let allModifiers = true;
         let allDecorators = true;
         for (const n of nodes) {
-            if (n.kind === 171 /* SyntaxKind.Decorator */)
+            if (n.kind === 172 /* SyntaxKind.Decorator */)
                 allModifiers = false;
             else
                 allDecorators = false;
@@ -760,7 +866,7 @@ export class Printer extends NameGeneratorHost {
             let pos = 0;
             while (start < nodes.length) {
                 while (pos < nodes.length) {
-                    decorators = nodes[pos].kind === 171 /* SyntaxKind.Decorator */;
+                    decorators = nodes[pos].kind === 172 /* SyntaxKind.Decorator */;
                     if (!haveMode) {
                         lastDecorators = decorators;
                         haveMode = true;
@@ -826,7 +932,7 @@ export class Printer extends NameGeneratorHost {
     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));
+        return this.emitList(2 /* ListItem.TypeParameter */, parent, nodes, 53776 /* ListFormat.TypeParameters */ | (parent.kind === 221 /* SyntaxKind.ArrowFunction */ ? 64 /* ListFormat.AllowTrailingComma */ : 0));
     }
     emitTypeAnnotation(node) {
         if (node === undefined)
@@ -1027,39 +1133,39 @@ export class Printer extends NameGeneratorHost {
     }
     emitClassElement(node) {
         switch (node.kind) {
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (node instanceof PropertyDeclaration)
                     return this.emitPropertyDeclaration(node);
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration)
                     return this.emitMethodDeclaration(node);
                 break;
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 if (node instanceof ClassStaticBlockDeclaration)
                     return this.emitClassStaticBlockDeclaration(node);
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (node instanceof ConstructorDeclaration)
                     return this.emitConstructor(node);
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration)
                     return this.emitGetAccessor(node);
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration)
                     return this.emitSetAccessor(node);
                 break;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 if (node instanceof IndexSignatureDeclaration)
                     return this.emitIndexSignature(node);
                 break;
-            case 241 /* SyntaxKind.SemicolonClassElement */:
+            case 242 /* SyntaxKind.SemicolonClassElement */:
                 return this.emitSimpleNode(node, ';');
-            case 347 /* SyntaxKind.NotEmittedStatement */:
+            case 348 /* SyntaxKind.NotEmittedStatement */:
                 return this.emitSimpleNode(node, '');
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 if (node instanceof TypeAliasDeclaration)
                     return this.emitTypeAliasDeclaration(node);
                 break;
@@ -1068,62 +1174,62 @@ export class Printer extends NameGeneratorHost {
     }
     emitTypeElement(node) {
         switch (node.kind) {
-            case 172 /* SyntaxKind.PropertySignature */:
+            case 173 /* SyntaxKind.PropertySignature */:
                 if (node instanceof PropertySignatureDeclaration)
                     return this.emitPropertySignature(node);
                 break;
-            case 174 /* SyntaxKind.MethodSignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
                 if (node instanceof MethodSignatureDeclaration)
                     return this.emitMethodSignature(node);
                 break;
-            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
                 if (node instanceof CallSignatureDeclaration)
                     return this.emitCallSignature(node);
                 break;
-            case 181 /* SyntaxKind.ConstructSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
                 if (node instanceof ConstructSignatureDeclaration)
                     return this.emitConstructSignature(node);
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration)
                     return this.emitGetAccessor(node);
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration)
                     return this.emitSetAccessor(node);
                 break;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 if (node instanceof IndexSignatureDeclaration)
                     return this.emitIndexSignature(node);
                 break;
-            case 350 /* SyntaxKind.NotEmittedTypeElement */:
+            case 351 /* SyntaxKind.NotEmittedTypeElement */:
                 return this.emitSimpleNode(node, '');
         }
         throw new Error('Unexpected type element ' + node.kind);
     }
     emitObjectLiteralElement(node) {
         switch (node.kind) {
-            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
                 if (node instanceof PropertyAssignment)
                     return this.emitPropertyAssignment(node);
                 break;
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 if (node instanceof ShorthandPropertyAssignment)
                     return this.emitShorthandPropertyAssignment(node);
                 break;
-            case 305 /* SyntaxKind.SpreadAssignment */:
+            case 306 /* SyntaxKind.SpreadAssignment */:
                 if (node instanceof SpreadAssignment)
                     return this.emitSpreadAssignment(node);
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration)
                     return this.emitMethodDeclaration(node);
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration)
                     return this.emitGetAccessor(node);
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration)
                     return this.emitSetAccessor(node);
                 break;
@@ -1214,7 +1320,7 @@ export class Printer extends NameGeneratorHost {
     }
     /** 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 */)
+        if (isParseTreeNode(parent) && operand.kind === 188 /* SyntaxKind.TypeQuery */)
             return this.emitTypeNode(operand, 5 /* TypePrecedence.TypeOperator */);
         return this.emitTypeNode(operand, 6 /* TypePrecedence.Postfix */);
     }
@@ -1312,11 +1418,11 @@ export class Printer extends NameGeneratorHost {
             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);
+        // A mapped type written without a type, `{ [K in keyof T] }`, prints without one.
+        if (node.type !== undefined) {
+            this.write1(': ');
+            this.emitTypeNodeOutsideExtends(node.type);
+        }
         this.write1(';');
         if (node.members !== undefined && node.members.nodes.length > 0) {
             if (singleLine)
@@ -1419,15 +1525,15 @@ export class Printer extends NameGeneratorHost {
             case 146 /* SyntaxKind.NeverKeyword */:
             case 141 /* SyntaxKind.IntrinsicKeyword */:
                 return this.emitTokenNode(node);
-            case 310 /* SyntaxKind.JSDocAllType */:
+            case 311 /* SyntaxKind.JSDocAllType */:
                 return this.emitSimpleNode(node, tokenToString(node.kind));
-            case 198 /* SyntaxKind.ThisType */:
+            case 199 /* SyntaxKind.ThisType */:
                 return this.emitSimpleNode(node, 'this');
-            case 183 /* SyntaxKind.TypePredicate */:
+            case 184 /* SyntaxKind.TypePredicate */:
                 if (node instanceof TypePredicateNode)
                     return this.emitTypePredicate(node);
                 break;
-            case 184 /* SyntaxKind.TypeReference */:
+            case 185 /* SyntaxKind.TypeReference */:
                 if (node instanceof TypeReferenceNode) {
                     const state = this.enterNode(node);
                     this.emitEntityName(node.typeName);
@@ -1436,15 +1542,15 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.FunctionType */:
                 if (node instanceof FunctionTypeNode)
                     return this.emitFunctionType(node);
                 break;
-            case 186 /* SyntaxKind.ConstructorType */:
+            case 187 /* SyntaxKind.ConstructorType */:
                 if (node instanceof ConstructorTypeNode)
                     return this.emitConstructorType(node);
                 break;
-            case 187 /* SyntaxKind.TypeQuery */:
+            case 188 /* SyntaxKind.TypeQuery */:
                 if (node instanceof TypeQueryNode) {
                     const state = this.enterNode(node);
                     this.write1('typeof ');
@@ -1454,11 +1560,11 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 188 /* SyntaxKind.TypeLiteral */:
+            case 189 /* SyntaxKind.TypeLiteral */:
                 if (node instanceof TypeLiteralNode)
                     return this.emitTypeLiteral(node);
                 break;
-            case 189 /* SyntaxKind.ArrayType */:
+            case 190 /* SyntaxKind.ArrayType */:
                 if (node instanceof ArrayTypeNode) {
                     const state = this.enterNode(node);
                     this.emitPostfixTypeOperand(node.elementType, node);
@@ -1468,11 +1574,11 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 190 /* SyntaxKind.TupleType */:
+            case 191 /* SyntaxKind.TupleType */:
                 if (node instanceof TupleTypeNode)
                     return this.emitTupleType(node);
                 break;
-            case 191 /* SyntaxKind.OptionalType */:
+            case 192 /* SyntaxKind.OptionalType */:
                 if (node instanceof OptionalTypeNode) {
                     const state = this.enterNode(node);
                     this.emitPostfixTypeOperand(node.type, node);
@@ -1481,7 +1587,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 192 /* SyntaxKind.RestType */:
+            case 193 /* SyntaxKind.RestType */:
                 if (node instanceof RestTypeNode) {
                     const state = this.enterNode(node);
                     this.write1('...');
@@ -1490,7 +1596,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.UnionType */:
                 if (node instanceof UnionTypeNode) {
                     const state = this.enterNode(node);
                     this.emitList(8 /* ListItem.UnionConstituent */, node, node.types, 516 /* ListFormat.UnionTypeConstituents */);
@@ -1498,7 +1604,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 194 /* SyntaxKind.IntersectionType */:
+            case 195 /* SyntaxKind.IntersectionType */:
                 if (node instanceof IntersectionTypeNode) {
                     const state = this.enterNode(node);
                     this.emitList(8 /* ListItem.UnionConstituent */, node, node.types, 520 /* ListFormat.IntersectionTypeConstituents */);
@@ -1506,15 +1612,15 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 195 /* SyntaxKind.ConditionalType */:
+            case 196 /* SyntaxKind.ConditionalType */:
                 if (node instanceof ConditionalTypeNode)
                     return this.emitConditionalType(node);
                 break;
-            case 196 /* SyntaxKind.InferType */:
+            case 197 /* SyntaxKind.InferType */:
                 if (node instanceof InferTypeNode)
                     return this.emitInferType(node);
                 break;
-            case 197 /* SyntaxKind.ParenthesizedType */:
+            case 198 /* SyntaxKind.ParenthesizedType */:
                 if (node instanceof ParenthesizedTypeNode) {
                     const state = this.enterNode(node);
                     this.write1('(');
@@ -1524,11 +1630,11 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 199 /* SyntaxKind.TypeOperator */:
+            case 200 /* SyntaxKind.TypeOperator */:
                 if (node instanceof TypeOperatorNode)
                     return this.emitTypeOperator(node);
                 break;
-            case 200 /* SyntaxKind.IndexedAccessType */:
+            case 201 /* SyntaxKind.IndexedAccessType */:
                 if (node instanceof IndexedAccessTypeNode) {
                     const state = this.enterNode(node);
                     this.emitPostfixTypeOperand(node.objectType, node);
@@ -1539,11 +1645,11 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 201 /* SyntaxKind.MappedType */:
+            case 202 /* SyntaxKind.MappedType */:
                 if (node instanceof MappedTypeNode)
                     return this.emitMappedType(node);
                 break;
-            case 202 /* SyntaxKind.LiteralType */:
+            case 203 /* SyntaxKind.LiteralType */:
                 if (node instanceof LiteralTypeNode) {
                     const state = this.enterNode(node);
                     this.emitExpression(node.literal, 0 /* OperatorPrecedence.Comma */);
@@ -1551,39 +1657,39 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 203 /* SyntaxKind.NamedTupleMember */:
+            case 204 /* SyntaxKind.NamedTupleMember */:
                 if (node instanceof NamedTupleMember)
                     return this.emitNamedTupleMember(node);
                 break;
-            case 204 /* SyntaxKind.TemplateLiteralType */:
+            case 205 /* SyntaxKind.TemplateLiteralType */:
                 if (node instanceof TemplateLiteralTypeNode)
                     return this.emitTemplateType(node);
                 break;
-            case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+            case 206 /* SyntaxKind.TemplateLiteralTypeSpan */:
                 if (node instanceof TemplateLiteralTypeSpan)
                     return this.emitTemplateTypeSpan(node);
                 break;
-            case 206 /* SyntaxKind.ImportType */:
+            case 207 /* SyntaxKind.ImportType */:
                 if (node instanceof ImportTypeNode)
                     return this.emitImportType(node);
                 break;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 if (node instanceof PropertyAccessExpression)
                     return this.emitPropertyAccessExpression(node);
                 break;
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
                 if (node instanceof ExpressionWithTypeArguments)
                     return this.emitExpressionWithTypeArguments(node);
                 break;
-            case 312 /* SyntaxKind.JSDocNonNullableType */:
+            case 313 /* SyntaxKind.JSDocNonNullableType */:
                 if (node instanceof JSDocNonNullableType)
                     return this.emitJSDocPrefixType(node, '!', node.type);
                 break;
-            case 311 /* SyntaxKind.JSDocNullableType */:
+            case 312 /* SyntaxKind.JSDocNullableType */:
                 if (node instanceof JSDocNullableType)
                     return this.emitJSDocPrefixType(node, '?', node.type);
                 break;
-            case 313 /* SyntaxKind.JSDocOptionalType */:
+            case 314 /* SyntaxKind.JSDocOptionalType */:
                 if (node instanceof JSDocOptionalType) {
                     const state = this.enterNode(node);
                     this.emitTypeNode(node.type, 1 /* TypePrecedence.JSDoc */);
@@ -1592,7 +1698,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 314 /* SyntaxKind.JSDocVariadicType */:
+            case 315 /* SyntaxKind.JSDocVariadicType */:
                 if (node instanceof JSDocVariadicType) {
                     const state = this.enterNode(node);
                     this.write1('...');
@@ -1614,7 +1720,7 @@ export class Printer extends NameGeneratorHost {
     // Binding patterns
     emitBindingPattern(node) {
         const state = this.enterNode(node);
-        const object = node.kind === 207 /* SyntaxKind.ObjectBindingPattern */;
+        const object = node.kind === 208 /* SyntaxKind.ObjectBindingPattern */;
         this.write1(object ? '{' : '[');
         this.emitList(11 /* ListItem.BindingElement */, node, node.elements, object ? 525136 /* ListFormat.ObjectBindingPatternElements */ : 524880 /* ListFormat.ArrayBindingPatternElements */);
         this.write1(object ? '}' : ']');
@@ -1720,7 +1826,7 @@ export class Printer extends NameGeneratorHost {
             this.emitExpression(callee, 0 /* OperatorPrecedence.Comma */);
             return this.write1(')');
         }
-        if (parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+        if (parent.kind === 215 /* SyntaxKind.CallExpression */ &&
             isNewExpressionWithoutArguments(skipPartiallyEmittedExpressions(callee)))
             return this.emitExpression(callee, 22 /* OperatorPrecedence.Parentheses */);
         return this.emitExpression(callee, isOptionalChain(parent) ? 19 /* OperatorPrecedence.OptionalChain */ : 20 /* OperatorPrecedence.Member */);
@@ -1738,7 +1844,7 @@ export class Printer extends NameGeneratorHost {
         const state = this.enterNode(node);
         this.emitToken(104 /* SyntaxKind.NewKeyword */, node.pos, node);
         this.space();
-        if (skipPartiallyEmittedExpressions(node.expression).kind === 214 /* SyntaxKind.CallExpression */)
+        if (skipPartiallyEmittedExpressions(node.expression).kind === 215 /* SyntaxKind.CallExpression */)
             this.emitExpression(node.expression, 22 /* OperatorPrecedence.Parentheses */);
         else
             this.emitExpression(node.expression, 20 /* OperatorPrecedence.Member */);
@@ -1787,7 +1893,7 @@ export class Printer extends NameGeneratorHost {
     emitConciseBody(node) {
         if (node instanceof Block)
             return this.emitFunctionBody(node);
-        if (getLeftmostExpression(node, false).kind === 211 /* SyntaxKind.ObjectLiteralExpression */) {
+        if (getLeftmostExpression(node, false).kind === 212 /* SyntaxKind.ObjectLiteralExpression */) {
             const paren = this.context.factory.createParenthesizedExpression(node);
             paren.pos = node.pos;
             paren.end = node.end;
@@ -2048,7 +2154,7 @@ export class Printer extends NameGeneratorHost {
             const parseNode = this.context.parseNode(node);
             if (parseNode !== undefined &&
                 parseNode.parent !== undefined &&
-                parseNode.parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+                parseNode.parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
                 return true;
         }
         if (hasNewLineComment)
@@ -2146,35 +2252,35 @@ export class Printer extends NameGeneratorHost {
                 if (node instanceof PrivateIdentifier)
                     return this.emitPrivateIdentifier(node);
                 break;
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
                 if (node instanceof ArrayLiteralExpression)
                     return this.emitArrayLiteralExpression(node);
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 if (node instanceof ObjectLiteralExpression)
                     return this.emitObjectLiteralExpression(node);
                 break;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 if (node instanceof PropertyAccessExpression)
                     return this.emitPropertyAccessExpression(node);
                 break;
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if (node instanceof ElementAccessExpression)
                     return this.emitElementAccessExpression(node);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (node instanceof CallExpression)
                     return this.emitCallExpression(node);
                 break;
-            case 215 /* SyntaxKind.NewExpression */:
+            case 216 /* SyntaxKind.NewExpression */:
                 if (node instanceof NewExpression)
                     return this.emitNewExpression(node);
                 break;
-            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            case 217 /* SyntaxKind.TaggedTemplateExpression */:
                 if (node instanceof TaggedTemplateExpression)
                     return this.emitTaggedTemplateExpression(node);
                 break;
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
                 if (node instanceof TypeAssertion) {
                     const state = this.enterNode(node);
                     this.write1('<');
@@ -2185,77 +2291,77 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 if (node instanceof ParenthesizedExpression)
                     return this.emitParenthesizedExpression(node);
                 break;
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 if (node instanceof FunctionExpression)
                     return this.emitFunctionExpression(node);
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (node instanceof ArrowFunction)
                     return this.emitArrowFunction(node);
                 break;
-            case 221 /* SyntaxKind.DeleteExpression */:
+            case 222 /* SyntaxKind.DeleteExpression */:
                 if (node instanceof DeleteExpression)
                     return this.emitKeywordUnary(node, 90 /* SyntaxKind.DeleteKeyword */, node.expression);
                 break;
-            case 222 /* SyntaxKind.TypeOfExpression */:
+            case 223 /* SyntaxKind.TypeOfExpression */:
                 if (node instanceof TypeOfExpression)
                     return this.emitKeywordUnary(node, 113 /* SyntaxKind.TypeOfKeyword */, node.expression);
                 break;
-            case 223 /* SyntaxKind.VoidExpression */:
+            case 224 /* SyntaxKind.VoidExpression */:
                 if (node instanceof VoidExpression)
                     return this.emitKeywordUnary(node, 115 /* SyntaxKind.VoidKeyword */, node.expression);
                 break;
-            case 224 /* SyntaxKind.AwaitExpression */:
+            case 225 /* SyntaxKind.AwaitExpression */:
                 if (node instanceof AwaitExpression)
                     return this.emitKeywordUnary(node, 134 /* SyntaxKind.AwaitKeyword */, node.expression);
                 break;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 if (node instanceof PrefixUnaryExpression)
                     return this.emitPrefixUnaryExpression(node);
                 break;
-            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            case 227 /* SyntaxKind.PostfixUnaryExpression */:
                 if (node instanceof PostfixUnaryExpression)
                     return this.emitPostfixUnaryExpression(node);
                 break;
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 if (node instanceof BinaryExpression)
                     return this.emitBinaryExpression(node);
                 break;
-            case 228 /* SyntaxKind.ConditionalExpression */:
+            case 229 /* SyntaxKind.ConditionalExpression */:
                 if (node instanceof ConditionalExpression)
                     return this.emitConditionalExpression(node);
                 break;
-            case 229 /* SyntaxKind.TemplateExpression */:
+            case 230 /* SyntaxKind.TemplateExpression */:
                 if (node instanceof TemplateExpression)
                     return this.emitTemplateExpression(node);
                 break;
-            case 230 /* SyntaxKind.YieldExpression */:
+            case 231 /* SyntaxKind.YieldExpression */:
                 if (node instanceof YieldExpression)
                     return this.emitYieldExpression(node);
                 break;
-            case 231 /* SyntaxKind.SpreadElement */:
+            case 232 /* SyntaxKind.SpreadElement */:
                 if (node instanceof SpreadElement)
                     return this.emitSpreadElement(node);
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* 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 */:
+            case 234 /* SyntaxKind.OmittedExpression */:
                 return this.emitSimpleNode(node, '');
-            case 235 /* SyntaxKind.AsExpression */:
+            case 236 /* SyntaxKind.AsExpression */:
                 if (node instanceof AsExpression)
                     return this.emitTypeRelation(node, node.expression, 'as', node.type);
                 break;
-            case 239 /* SyntaxKind.SatisfiesExpression */:
+            case 240 /* SyntaxKind.SatisfiesExpression */:
                 if (node instanceof SatisfiesExpression)
                     return this.emitTypeRelation(node, node.expression, 'satisfies', node.type);
                 break;
-            case 236 /* SyntaxKind.NonNullExpression */:
+            case 237 /* SyntaxKind.NonNullExpression */:
                 if (node instanceof NonNullExpression) {
                     const state = this.enterNode(node);
                     this.emitExpression(node.expression, 20 /* OperatorPrecedence.Member */);
@@ -2264,36 +2370,36 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
                 if (node instanceof ExpressionWithTypeArguments)
                     return this.emitExpressionWithTypeArguments(node);
                 break;
-            case 237 /* SyntaxKind.MetaProperty */:
+            case 238 /* SyntaxKind.MetaProperty */:
                 if (node instanceof MetaProperty) {
                     const state = this.enterNode(node);
-                    this.emitToken(node.keywordToken, node.pos, node);
-                    this.write1('.');
+                    const pos = this.emitToken(node.keywordToken, node.pos, node);
+                    this.emitToken(24 /* SyntaxKind.DotToken */, pos, node);
                     this.emitIdentifierName(node.name);
                     this.exitNode(node, state);
                     return true;
                 }
                 break;
-            case 283 /* SyntaxKind.MissingDeclaration */:
-            case 347 /* SyntaxKind.NotEmittedStatement */:
+            case 284 /* SyntaxKind.MissingDeclaration */:
+            case 348 /* SyntaxKind.NotEmittedStatement */:
                 return false;
-            case 285 /* SyntaxKind.JsxElement */:
+            case 286 /* SyntaxKind.JsxElement */:
                 if (node instanceof JsxElement)
                     return this.emitJsxElement(node);
                 break;
-            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            case 287 /* SyntaxKind.JsxSelfClosingElement */:
                 if (node instanceof JsxSelfClosingElement)
                     return this.emitJsxSelfClosingElement(node);
                 break;
-            case 289 /* SyntaxKind.JsxFragment */:
+            case 290 /* SyntaxKind.JsxFragment */:
                 if (node instanceof JsxFragment)
                     return this.emitJsxFragment(node);
                 break;
-            case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            case 349 /* SyntaxKind.PartiallyEmittedExpression */:
                 if (node instanceof PartiallyEmittedExpression)
                     return this.emitPartiallyEmittedExpression(node);
                 break;
@@ -2347,7 +2453,7 @@ export class Printer extends NameGeneratorHost {
         }
         else {
             const leftmost = getLeftmostExpression(expression, false).kind;
-            this.emitExpression(expression, leftmost === 219 /* SyntaxKind.FunctionExpression */ || leftmost === 211 /* SyntaxKind.ObjectLiteralExpression */
+            this.emitExpression(expression, leftmost === 220 /* SyntaxKind.FunctionExpression */ || leftmost === 212 /* SyntaxKind.ObjectLiteralExpression */
                 ? 22 /* OperatorPrecedence.Parentheses */
                 : 0 /* OperatorPrecedence.Comma */);
         }
@@ -2431,14 +2537,14 @@ export class Printer extends NameGeneratorHost {
         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) {
+        if (node.kind === 252 /* 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.emitToken(node.kind === 252 /* 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);
@@ -2602,6 +2708,10 @@ export class Printer extends NameGeneratorHost {
             this.emitIdentifierOrString(body.name, false);
             body = body.body;
         }
+        if (node.attributes !== undefined) {
+            this.write1(' with ');
+            this.emitTypeNode(node.attributes, 7 /* TypePrecedence.NonArray */);
+        }
         if (body === undefined)
             this.write1(';');
         else if (body instanceof ModuleBlock) {
@@ -2709,15 +2819,19 @@ export class Printer extends NameGeneratorHost {
             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.emitNamedImports(bindings);
         }
         this.exitNode(node, state);
         return true;
     }
+    emitNamedImports(node) {
+        const state = this.enterNode(node);
+        this.write1('{');
+        this.emitList(20 /* ListItem.ImportSpecifier */, node, node.elements, 525136 /* ListFormat.NamedImportsOrExportsElements */);
+        this.write1('}');
+        this.exitNode(node, state);
+        return true;
+    }
     /** Import and export specifiers. */
     emitSpecifier(node, isTypeOnly, propertyName, name, binding) {
         const state = this.enterNode(node);
@@ -2743,7 +2857,7 @@ export class Printer extends NameGeneratorHost {
             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 */
+            this.emitExpression(node.expression, leftmost === 233 /* SyntaxKind.ClassExpression */ || leftmost === 220 /* SyntaxKind.FunctionExpression */
                 ? 22 /* OperatorPrecedence.Parentheses */
                 : 3 /* OperatorPrecedence.Assignment */);
         }
@@ -2828,29 +2942,29 @@ export class Printer extends NameGeneratorHost {
     }
     emitStatement(node) {
         switch (node.kind) {
-            case 242 /* SyntaxKind.Block */:
+            case 243 /* SyntaxKind.Block */:
                 if (node instanceof Block)
                     return this.emitBlock(node);
                 break;
-            case 243 /* SyntaxKind.EmptyStatement */:
+            case 244 /* SyntaxKind.EmptyStatement */:
                 return this.emitSimpleNode(node, ';');
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 if (node instanceof VariableStatement)
                     return this.emitVariableStatement(node);
                 break;
-            case 245 /* SyntaxKind.ExpressionStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 if (node instanceof ExpressionStatement)
                     return this.emitExpressionStatement(node);
                 break;
-            case 246 /* SyntaxKind.IfStatement */:
+            case 247 /* SyntaxKind.IfStatement */:
                 if (node instanceof IfStatement)
                     return this.emitIfStatement(node);
                 break;
-            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
                 if (node instanceof DoStatement)
                     return this.emitDoStatement(node);
                 break;
-            case 248 /* SyntaxKind.WhileStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
                 if (node instanceof WhileStatement) {
                     const state = this.enterNode(node);
                     this.emitKeywordAndParenthesizedExpression(node, 116 /* SyntaxKind.WhileKeyword */, node.pos, node.expression);
@@ -2859,28 +2973,28 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 if (node instanceof ForStatement)
                     return this.emitForStatement(node);
                 break;
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 if (node instanceof ForInOrOfStatement)
                     return this.emitForInOrOfStatement(node);
                 break;
-            case 252 /* SyntaxKind.ContinueStatement */:
+            case 253 /* SyntaxKind.ContinueStatement */:
                 if (node instanceof ContinueStatement)
                     return this.emitJumpStatement(node, 87 /* SyntaxKind.ContinueKeyword */, node.label, undefined);
                 break;
-            case 253 /* SyntaxKind.BreakStatement */:
+            case 254 /* SyntaxKind.BreakStatement */:
                 if (node instanceof BreakStatement)
                     return this.emitJumpStatement(node, 82 /* SyntaxKind.BreakKeyword */, node.label, undefined);
                 break;
-            case 254 /* SyntaxKind.ReturnStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
                 if (node instanceof ReturnStatement)
                     return this.emitJumpStatement(node, 106 /* SyntaxKind.ReturnKeyword */, undefined, node.expression);
                 break;
-            case 255 /* SyntaxKind.WithStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
                 if (node instanceof WithStatement) {
                     const state = this.enterNode(node);
                     this.emitKeywordAndParenthesizedExpression(node, 117 /* SyntaxKind.WithKeyword */, node.pos, node.expression);
@@ -2889,7 +3003,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 256 /* SyntaxKind.SwitchStatement */:
+            case 257 /* SyntaxKind.SwitchStatement */:
                 if (node instanceof SwitchStatement) {
                     const state = this.enterNode(node);
                     this.emitKeywordAndParenthesizedExpression(node, 108 /* SyntaxKind.SwitchKeyword */, node.pos, node.expression);
@@ -2899,7 +3013,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 257 /* SyntaxKind.LabeledStatement */:
+            case 258 /* SyntaxKind.LabeledStatement */:
                 if (node instanceof LabeledStatement) {
                     const state = this.enterNode(node);
                     this.emitIdentifierName(node.label);
@@ -2910,7 +3024,7 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 258 /* SyntaxKind.ThrowStatement */:
+            case 259 /* SyntaxKind.ThrowStatement */:
                 if (node instanceof ThrowStatement) {
                     const state = this.enterNode(node);
                     this.emitToken(110 /* SyntaxKind.ThrowKeyword */, node.pos, node);
@@ -2921,11 +3035,11 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 259 /* SyntaxKind.TryStatement */:
+            case 260 /* SyntaxKind.TryStatement */:
                 if (node instanceof TryStatement)
                     return this.emitTryStatement(node);
                 break;
-            case 260 /* SyntaxKind.DebuggerStatement */:
+            case 261 /* SyntaxKind.DebuggerStatement */:
                 if (node instanceof DebuggerStatement) {
                     const state = this.enterNode(node);
                     this.emitToken(88 /* SyntaxKind.DebuggerKeyword */, node.pos, node);
@@ -2934,52 +3048,52 @@ export class Printer extends NameGeneratorHost {
                     return true;
                 }
                 break;
-            case 347 /* SyntaxKind.NotEmittedStatement */:
+            case 348 /* SyntaxKind.NotEmittedStatement */:
                 return this.emitSimpleNode(node, '');
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 if (node instanceof FunctionDeclaration)
                     return this.emitFunctionDeclaration(node);
                 break;
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* 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 */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
                 if (node instanceof InterfaceDeclaration)
                     return this.emitInterfaceDeclaration(node);
                 break;
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 if (node instanceof TypeAliasDeclaration)
                     return this.emitTypeAliasDeclaration(node);
                 break;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (node instanceof EnumDeclaration)
                     return this.emitEnumDeclaration(node);
                 break;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (node instanceof ModuleDeclaration)
                     return this.emitModuleDeclaration(node);
                 break;
-            case 283 /* SyntaxKind.MissingDeclaration */:
+            case 284 /* SyntaxKind.MissingDeclaration */:
                 return false;
-            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            case 272 /* SyntaxKind.NamespaceExportDeclaration */:
                 if (node instanceof NamespaceExportDeclaration)
                     return this.emitNamespaceExportDeclaration(node);
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (node instanceof ImportEqualsDeclaration)
                     return this.emitImportEqualsDeclaration(node);
                 break;
-            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
                 if (node instanceof ImportDeclaration)
                     return this.emitImportDeclaration(node);
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment)
                     return this.emitExportAssignment(node);
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (node instanceof ExportDeclaration)
                     return this.emitExportDeclaration(node);
                 break;
@@ -2990,7 +3104,7 @@ export class Printer extends NameGeneratorHost {
     emitJsxElement(node) {
         const state = this.enterNode(node);
         this.emitJsxOpeningElement(node.openingElement);
-        this.emitList(23 /* ListItem.JsxChild */, node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
+        this.emitList(24 /* ListItem.JsxChild */, node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
         this.emitJsxClosingElement(node.closingElement);
         this.exitNode(node, state);
         return true;
@@ -3009,7 +3123,7 @@ export class Printer extends NameGeneratorHost {
     emitJsxFragment(node) {
         const state = this.enterNode(node);
         this.emitSimpleNode(node.openingFragment, '<>');
-        this.emitList(23 /* ListItem.JsxChild */, node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
+        this.emitList(24 /* ListItem.JsxChild */, node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */);
         this.emitSimpleNode(node.closingFragment, '</>');
         this.exitNode(node, state);
         return true;
@@ -3039,7 +3153,7 @@ export class Printer extends NameGeneratorHost {
     }
     emitJsxAttributes(node) {
         const state = this.enterNode(node);
-        this.emitList(24 /* ListItem.JsxAttributeLike */, node, node.properties, 262656 /* ListFormat.JsxElementAttributes */);
+        this.emitList(25 /* ListItem.JsxAttributeLike */, node, node.properties, 262656 /* ListFormat.JsxElementAttributes */);
         this.exitNode(node, state);
         return true;
     }
@@ -3135,7 +3249,7 @@ export class Printer extends NameGeneratorHost {
     emitCaseOrDefaultClause(node) {
         const state = this.enterNode(node);
         let colonPos;
-        if (node.kind === 297 /* SyntaxKind.CaseClause */ && node.expression !== undefined) {
+        if (node.kind === 298 /* SyntaxKind.CaseClause */ && node.expression !== undefined) {
             this.emitToken(83 /* SyntaxKind.CaseKeyword */, node.pos, node);
             this.space();
             this.emitExpression(node.expression, 0 /* OperatorPrecedence.Lowest */);
@@ -3167,7 +3281,7 @@ export class Printer extends NameGeneratorHost {
         this.space();
         this.emitToken(node.token, node.pos, node);
         this.space();
-        this.emitList(22 /* ListItem.ExpressionWithTypeArguments */, node, node.types, 528 /* ListFormat.HeritageClauseTypes */);
+        this.emitList(23 /* ListItem.HeritageClauseElement */, node, node.types, 528 /* ListFormat.HeritageClauseTypes */);
         this.exitNode(node, state);
         return true;
     }
@@ -3392,9 +3506,15 @@ export class Printer extends NameGeneratorHost {
                 if (node instanceof ExpressionWithTypeArguments)
                     return this.emitExpressionWithTypeArguments(node);
                 break;
-            case 23 /* ListItem.JsxChild */:
+            case 23 /* ListItem.HeritageClauseElement */:
+                if (node instanceof ExpressionWithTypeArguments)
+                    return this.emitExpressionWithTypeArguments(node);
+                if (node.kind === 185 /* SyntaxKind.TypeReference */)
+                    return this.emitTypeNodeWorker(node);
+                break;
+            case 24 /* ListItem.JsxChild */:
                 return this.emitJsxChild(node);
-            case 24 /* ListItem.JsxAttributeLike */:
+            case 25 /* ListItem.JsxAttributeLike */:
                 if (node instanceof JsxAttribute)
                     return this.emitJsxAttribute(node);
                 if (node instanceof JsxSpreadAttribute) {
@@ -3455,48 +3575,48 @@ export class Printer extends NameGeneratorHost {
             return false;
         let originalList = children;
         switch (original.kind) {
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* 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 */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
+            case 208 /* SyntaxKind.ObjectBindingPattern */:
+            case 209 /* SyntaxKind.ArrayBindingPattern */:
+            case 277 /* SyntaxKind.NamedImports */:
+            case 281 /* SyntaxKind.NamedExports */:
                 originalList = getElements(original);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
-            case 215 /* SyntaxKind.NewExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
+            case 216 /* 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 */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.ConstructorType */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* 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 */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 if (children === getTypeParameters(parent))
                     originalList = getTypeParameters(original);
                 break;
-            case 301 /* SyntaxKind.ImportAttributes */:
+            case 302 /* SyntaxKind.ImportAttributes */:
                 if (original instanceof ImportAttributes)
                     originalList = original.attributes;
                 break;
@@ -3611,126 +3731,130 @@ export class Printer extends NameGeneratorHost {
                 if (node instanceof PrivateIdentifier)
                     return this.emitPrivateIdentifier(node);
                 break;
-            case 167 /* SyntaxKind.QualifiedName */:
+            case 168 /* SyntaxKind.QualifiedName */:
                 if (node instanceof QualifiedName)
                     return this.emitQualifiedName(node);
                 break;
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 if (node instanceof ComputedPropertyName)
                     return this.emitComputedPropertyName(node);
                 break;
-            case 169 /* SyntaxKind.TypeParameter */:
+            case 170 /* SyntaxKind.TypeParameter */:
                 if (node instanceof TypeParameterDeclaration)
                     return this.emitTypeParameter(node);
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (node instanceof ParameterDeclaration)
                     return this.emitParameter(node);
                 break;
-            case 171 /* SyntaxKind.Decorator */:
+            case 172 /* 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 */:
+            case 173 /* SyntaxKind.PropertySignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
+            case 351 /* 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 */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 183 /* SyntaxKind.IndexSignature */:
+            case 242 /* SyntaxKind.SemicolonClassElement */:
                 return this.emitClassElement(node);
-            case 207 /* SyntaxKind.ObjectBindingPattern */:
-            case 208 /* SyntaxKind.ArrayBindingPattern */:
+            case 208 /* SyntaxKind.ObjectBindingPattern */:
+            case 209 /* SyntaxKind.ArrayBindingPattern */:
                 if (node instanceof BindingPattern)
                     return this.emitBindingPattern(node);
                 break;
-            case 209 /* SyntaxKind.BindingElement */:
+            case 210 /* SyntaxKind.BindingElement */:
                 if (node instanceof BindingElement)
                     return this.emitBindingElement(node);
                 break;
-            case 240 /* SyntaxKind.TemplateSpan */:
+            case 241 /* SyntaxKind.TemplateSpan */:
                 return this.emitListItem(14 /* ListItem.TemplateSpan */, node);
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 if (node instanceof VariableDeclaration)
                     return this.emitVariableDeclaration(node);
                 break;
-            case 262 /* SyntaxKind.VariableDeclarationList */:
+            case 263 /* SyntaxKind.VariableDeclarationList */:
                 if (node instanceof VariableDeclarationList)
                     return this.emitVariableDeclarationList(node);
                 break;
-            case 269 /* SyntaxKind.ModuleBlock */:
+            case 270 /* SyntaxKind.ModuleBlock */:
                 if (node instanceof ModuleBlock)
                     return this.emitBlockLike(node, node.statements, false);
                 break;
-            case 270 /* SyntaxKind.CaseBlock */:
+            case 271 /* SyntaxKind.CaseBlock */:
                 if (node instanceof CaseBlock)
                     return this.emitBlockLike(node, node.clauses, true);
                 break;
-            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.ImportClause */:
                 if (node instanceof ImportClause)
                     return this.emitImportClause(node);
                 break;
-            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 277 /* SyntaxKind.NamedImports */:
+                if (node instanceof NamedImports)
+                    return this.emitNamedImports(node);
+                break;
+            case 278 /* SyntaxKind.ImportSpecifier */:
                 return this.emitListItem(20 /* ListItem.ImportSpecifier */, node);
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 return this.emitListItem(21 /* ListItem.ExportSpecifier */, node);
-            case 301 /* SyntaxKind.ImportAttributes */:
+            case 302 /* SyntaxKind.ImportAttributes */:
                 if (node instanceof ImportAttributes)
                     return this.emitImportAttributes(node);
                 break;
-            case 302 /* SyntaxKind.ImportAttribute */:
+            case 303 /* SyntaxKind.ImportAttribute */:
                 if (node instanceof ImportAttribute)
                     return this.emitImportAttribute(node);
                 break;
             case 11 /* SyntaxKind.JsxText */:
-            case 295 /* SyntaxKind.JsxExpression */:
+            case 296 /* SyntaxKind.JsxExpression */:
                 return this.emitJsxChild(node);
-            case 287 /* SyntaxKind.JsxOpeningElement */:
+            case 288 /* SyntaxKind.JsxOpeningElement */:
                 if (node instanceof JsxOpeningElement)
                     return this.emitJsxOpeningElement(node);
                 break;
-            case 288 /* SyntaxKind.JsxClosingElement */:
+            case 289 /* 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 */:
+            case 293 /* SyntaxKind.JsxAttribute */:
+            case 295 /* SyntaxKind.JsxSpreadAttribute */:
+                return this.emitListItem(25 /* ListItem.JsxAttributeLike */, node);
+            case 294 /* SyntaxKind.JsxAttributes */:
                 if (node instanceof JsxAttributes)
                     return this.emitJsxAttributes(node);
                 break;
-            case 296 /* SyntaxKind.JsxNamespacedName */:
+            case 297 /* SyntaxKind.JsxNamespacedName */:
                 return this.emitJsxName(node);
-            case 297 /* SyntaxKind.CaseClause */:
-            case 298 /* SyntaxKind.DefaultClause */:
+            case 298 /* SyntaxKind.CaseClause */:
+            case 299 /* SyntaxKind.DefaultClause */:
                 if (node instanceof CaseOrDefaultClause)
                     return this.emitCaseOrDefaultClause(node);
                 break;
-            case 299 /* SyntaxKind.HeritageClause */:
+            case 300 /* SyntaxKind.HeritageClause */:
                 if (node instanceof HeritageClause)
                     return this.emitHeritageClause(node);
                 break;
-            case 300 /* SyntaxKind.CatchClause */:
+            case 301 /* SyntaxKind.CatchClause */:
                 if (node instanceof CatchClause)
                     return this.emitCatchClause(node);
                 break;
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-            case 305 /* SyntaxKind.SpreadAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 306 /* SyntaxKind.SpreadAssignment */:
                 return this.emitObjectLiteralElement(node);
-            case 306 /* SyntaxKind.EnumMember */:
+            case 307 /* SyntaxKind.EnumMember */:
                 if (node instanceof EnumMember)
                     return this.emitEnumMember(node);
                 break;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile)
                     return this.emitSourceFileNode(node);
                 break;
@@ -3751,10 +3875,19 @@ export class Printer extends NameGeneratorHost {
     emitCommentsBeforeNode(node) {
         if (!this.shouldEmitComments(node))
             return false;
+        if (this.inCommentFreeRange(node)) {
+            // What the general path does for a node without emit data and without comments.
+            this.pushCommentState(commentFreeNode, node.pos, node.end);
+            this.containerPos = node.pos;
+            this.containerEnd = node.end;
+            if (node.kind === 263 /* SyntaxKind.VariableDeclarationList */)
+                this.declarationListContainerEnd = node.end;
+            return true;
+        }
         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.pushCommentState(flags, pos, end);
         this.emitLeadingCommentsOfNode(node, flags, pos, end);
         if ((flags & 128 /* EmitFlags.NoLeadingComments */) === 0) {
             const synthesized = this.context.getSyntheticLeadingComments(node);
@@ -3766,17 +3899,43 @@ export class Printer extends NameGeneratorHost {
             this.commentsDisabled = true;
         return true;
     }
+    /** Saves the comment state of a node: its emit flags (or `commentFreeNode`), comment range and the containers. */
+    pushCommentState(flags, pos, end) {
+        let stack = this.commentStack;
+        const at = this.commentDepth;
+        if (at + 6 > stack.length) {
+            const grown = new Int32Array(stack.length * 2);
+            grown.set(stack);
+            this.commentStack = grown;
+            stack = grown;
+        }
+        stack[at] = flags;
+        stack[at + 1] = pos;
+        stack[at + 2] = end;
+        stack[at + 3] = this.containerPos;
+        stack[at + 4] = this.containerEnd;
+        stack[at + 5] = this.declarationListContainerEnd;
+        this.commentDepth = at + 6;
+        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;
+        const base = this.commentDepth - 6;
+        const flags = stack[base];
+        const pos = stack[base + 1];
+        const end = stack[base + 2];
+        const containerPos = stack[base + 3];
+        const containerEnd = stack[base + 4];
+        const declarationListContainerEnd = stack[base + 5];
+        this.commentDepth = base;
+        if (node === this.freeOwner)
+            this.endCommentFreeRange();
+        if (flags === commentFreeNode) {
+            this.containerPos = containerPos;
+            this.containerEnd = containerEnd;
+            this.declarationListContainerEnd = declarationListContainerEnd;
+            return true;
+        }
         if ((flags & 512 /* EmitFlags.NoNestedComments */) !== 0)
             this.commentsDisabled = false;
         if ((flags & 256 /* EmitFlags.NoTrailingComments */) === 0) {
@@ -3792,6 +3951,87 @@ export class Printer extends NameGeneratorHost {
             this.emitTrailingCommentsOfNode(node, flags, typeNode.pos, typeNode.end, containerPos, containerEnd, declarationListContainerEnd);
         return true;
     }
+    /**
+     * Whether `node` has no emit data and lies in a range of the source text where no comment is found, so that its
+     * comments need not be looked for. Outside such a range, a node whose own range is one starts it (`freeOwner`).
+     */
+    inCommentFreeRange(node) {
+        const pos = node.pos;
+        const end = node.end;
+        if (pos < 0 || end <= pos || node.kind === 11 /* SyntaxKind.JsxText */ || node.kind === 348 /* SyntaxKind.NotEmittedStatement */)
+            return false;
+        if (this.freeEnd < 0) {
+            if (!this.startCommentFreeRange(pos, end))
+                return false;
+            this.freeOwner = node;
+        }
+        else if (pos < this.freeStart)
+            return false;
+        if (this.context.hasEmitNode(node))
+            return false;
+        return end < this.freeEnd || (end === this.freeEnd && this.freeEndTrailingNone);
+    }
+    endCommentFreeRange() {
+        this.freeStart = -1;
+        this.freeEnd = -1;
+        this.freeEndTrailingNone = false;
+        this.freeOwner = undefined;
+        return true;
+    }
+    /** Whether the comment-free range shows that no trailing comment follows `pos`. */
+    noCommentsAfter(pos) {
+        return pos >= this.freeStart && (pos < this.freeEnd || (pos === this.freeEnd && this.freeEndTrailingNone));
+    }
+    /** Makes `[pos, end)` the comment-free range if no comment starts in it and its last character is not trivia. */
+    startCommentFreeRange(pos, end) {
+        const text = this.sourceText;
+        if (end > text.length)
+            return false;
+        const last = text.charCodeAt(end - 1);
+        if (last === 32 /* CharacterCodes.space */ ||
+            last === 9 /* CharacterCodes.tab */ ||
+            last === 10 /* CharacterCodes.lineFeed */ ||
+            last === 13 /* CharacterCodes.carriageReturn */ ||
+            last === 11 /* CharacterCodes.verticalTab */ ||
+            last === 12 /* CharacterCodes.formFeed */ ||
+            last > 127 /* CharacterCodes.maxAsciiCharacter */)
+            return false;
+        const starts = this.commentStartsOfFile();
+        // The first comment start at or after `pos`.
+        let low = 0;
+        let high = starts.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (starts[middle] < pos)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        if (low < starts.length && starts[low] < end)
+            return false;
+        this.freeStart = pos;
+        this.freeEnd = end;
+        this.freeEndTrailingNone = getTrailingCommentRanges(text, end) === undefined;
+        return true;
+    }
+    commentStartsOfFile() {
+        const cached = this.commentStarts;
+        if (cached !== undefined)
+            return cached;
+        const text = this.sourceText;
+        const length = text.length;
+        const list = [];
+        for (let i = text.indexOf('/'); i >= 0 && i + 1 < length; i = text.indexOf('/', i + 1)) {
+            const next = text.charCodeAt(i + 1);
+            if (next === 47 /* CharacterCodes.slash */ || next === 42 /* CharacterCodes.asterisk */)
+                list.push(i);
+        }
+        const starts = new Int32Array(list.length);
+        for (let i = 0; i < list.length; i++)
+            starts[i] = list[i];
+        this.commentStarts = starts;
+        return starts;
+    }
     /** 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) {
@@ -3817,7 +4057,7 @@ export class Printer extends NameGeneratorHost {
     }
     emitCommentsAfterToken(pos, contextNode) {
         if (contextNode.end !== pos)
-            this.emitTrailingComments(pos, contextNode.kind === 295 /* SyntaxKind.JsxExpression */ ? 0 /* CommentSeparator.None */ : 1 /* CommentSeparator.Before */);
+            this.emitTrailingComments(pos, contextNode.kind === 296 /* SyntaxKind.JsxExpression */ ? 0 /* CommentSeparator.None */ : 1 /* CommentSeparator.Before */);
         return true;
     }
     emitDetachedCommentsBeforeStatementList(node, pos) {
@@ -3850,12 +4090,12 @@ export class Printer extends NameGeneratorHost {
         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 */);
+            this.emitLeadingComments(pos, node.kind === 348 /* 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 */)
+            if (node.kind === 263 /* SyntaxKind.VariableDeclarationList */)
                 this.declarationListContainerEnd = end;
         }
         return true;
@@ -3867,7 +4107,7 @@ export class Printer extends NameGeneratorHost {
         this.containerPos = containerPos;
         this.containerEnd = containerEnd;
         this.declarationListContainerEnd = declarationListContainerEnd;
-        if (!skipTrailing && node.kind !== 347 /* SyntaxKind.NotEmittedStatement */)
+        if (!skipTrailing && node.kind !== 348 /* SyntaxKind.NotEmittedStatement */)
             this.emitTrailingComments(end, 1 /* CommentSeparator.Before */);
         return true;
     }
@@ -3897,6 +4137,8 @@ export class Printer extends NameGeneratorHost {
     emitLeadingComments(pos, elided) {
         if (this.commentsDisabled || this.currentSourceFile === undefined || pos < 0 || pos === this.containerPos)
             return false;
+        if (pos >= this.freeStart && pos < this.freeEnd)
+            return false;
         // 1: only triple-slash comments, 2: all but triple-slash comments, 0: all.
         let tripleSlash = 0;
         if (!elided) {
@@ -3947,6 +4189,8 @@ export class Printer extends NameGeneratorHost {
             this.currentSourceFile === undefined ||
             (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd)))
             return false;
+        if (this.noCommentsAfter(pos))
+            return false;
         const ranges = getTrailingCommentRanges(this.sourceText, pos);
         if (ranges === undefined)
             return false;
@@ -3965,6 +4209,8 @@ export class Printer extends NameGeneratorHost {
             return false;
         if (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd))
             return false;
+        if (this.noCommentsAfter(pos))
+            return false;
         const comments = getTrailingCommentRanges(this.sourceText, pos);
         if (comments === undefined)
             return false;
@@ -4141,7 +4387,7 @@ export class Printer extends NameGeneratorHost {
         const flags = this.context.getEmitFlags(node);
         const pos = this.context.sourceMapPos(node);
         const end = this.context.sourceMapEnd(node);
-        if (node.kind !== 347 /* SyntaxKind.NotEmittedStatement */ &&
+        if (node.kind !== 348 /* SyntaxKind.NotEmittedStatement */ &&
             (flags & 4 /* EmitFlags.NoLeadingSourceMap */) === 0 &&
             this.currentSourceFile !== undefined &&
             pos >= 0)
@@ -4159,7 +4405,7 @@ export class Printer extends NameGeneratorHost {
         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)
+        if (node.kind !== 348 /* SyntaxKind.NotEmittedStatement */ && (flags & 8 /* EmitFlags.NoTrailingSourceMap */) === 0 && end >= 0)
             this.emitPos(end);
         return true;
     }
@@ -4295,14 +4541,14 @@ export class Printer extends NameGeneratorHost {
             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 */:
+                case 304 /* SyntaxKind.PropertyAssignment */:
+                case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+                case 174 /* SyntaxKind.PropertyDeclaration */:
+                case 173 /* SyntaxKind.PropertySignature */:
+                case 176 /* SyntaxKind.MethodDeclaration */:
+                case 175 /* SyntaxKind.MethodSignature */:
+                case 179 /* SyntaxKind.GetAccessor */:
+                case 180 /* SyntaxKind.SetAccessor */:
                     this.generateNameIfNeeded(getName(node));
             }
         }
@@ -4426,17 +4672,17 @@ function getContainingNodeArray(node) {
     if (parent === undefined)
         return undefined;
     switch (node.kind) {
-        case 169 /* SyntaxKind.TypeParameter */:
+        case 170 /* SyntaxKind.TypeParameter */:
             return getTypeParameters(parent);
-        case 170 /* SyntaxKind.Parameter */:
+        case 171 /* SyntaxKind.Parameter */:
             return getParameters(parent);
-        case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+        case 206 /* SyntaxKind.TemplateLiteralTypeSpan */:
             return parent instanceof TemplateLiteralTypeNode ? parent.templateSpans : undefined;
-        case 240 /* SyntaxKind.TemplateSpan */:
+        case 241 /* SyntaxKind.TemplateSpan */:
             return parent instanceof TemplateExpression ? parent.templateSpans : undefined;
-        case 171 /* SyntaxKind.Decorator */:
+        case 172 /* SyntaxKind.Decorator */:
             return getModifiers(parent);
-        case 299 /* SyntaxKind.HeritageClause */:
+        case 300 /* SyntaxKind.HeritageClause */:
             if (parent instanceof ClassDeclaration)
                 return parent.heritageClauses;
             if (parent instanceof ClassExpression)
@@ -4446,11 +4692,11 @@ function getContainingNodeArray(node) {
             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 */:
+        case 189 /* SyntaxKind.TypeLiteral */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             if (parent instanceof TypeLiteralNode)
                 return parent.members;
             if (parent instanceof InterfaceDeclaration)
@@ -4462,24 +4708,24 @@ function getContainingNodeArray(node) {
             if (parent instanceof EnumDeclaration)
                 return parent.members;
             break;
-        case 193 /* SyntaxKind.UnionType */:
+        case 194 /* SyntaxKind.UnionType */:
             if (parent instanceof UnionTypeNode)
                 return parent.types;
             break;
-        case 194 /* SyntaxKind.IntersectionType */:
+        case 195 /* 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 */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 191 /* SyntaxKind.TupleType */:
+        case 277 /* SyntaxKind.NamedImports */:
+        case 281 /* SyntaxKind.NamedExports */:
             return getElements(parent);
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 293 /* SyntaxKind.JsxAttributes */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 294 /* SyntaxKind.JsxAttributes */:
             return getProperties(parent);
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             if (isTypeNodeKind(node.kind))
                 return getTypeArguments(parent);
             if (parent instanceof CallExpression && node !== parent.expression)
@@ -4487,26 +4733,26 @@ function getContainingNodeArray(node) {
             if (parent instanceof NewExpression && node !== parent.expression)
                 return parent.arguments;
             break;
-        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxElement */:
             if (parent instanceof JsxElement)
                 return parent.children;
             break;
-        case 289 /* SyntaxKind.JsxFragment */:
+        case 290 /* SyntaxKind.JsxFragment */:
             if (parent instanceof JsxFragment)
                 return parent.children;
             break;
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* 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 */:
+        case 243 /* SyntaxKind.Block */:
+        case 270 /* SyntaxKind.ModuleBlock */:
+        case 298 /* SyntaxKind.CaseClause */:
+        case 299 /* SyntaxKind.DefaultClause */:
+        case 308 /* SyntaxKind.SourceFile */:
             return getStatements(parent);
-        case 270 /* SyntaxKind.CaseBlock */:
+        case 271 /* SyntaxKind.CaseBlock */:
             if (parent instanceof CaseBlock)
                 return parent.clauses;
             break;