tsc-ts 0.0.10 → 0.1.1

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

@@ -227,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) {
@@ -273,10 +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;
+                    return node instanceof Identifier ? node.text : node.text;
                 if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
                     if (node instanceof Identifier)
                         return node.text;
@@ -310,7 +311,8 @@ export class Printer extends NameGeneratorHost {
             return false;
         if ((node.flags & (8 /* NodeFlags.Reparsed */ | 4194304 /* NodeFlags.JSDoc */ | 268435456 /* NodeFlags.ReparserTransformedLiteral */)) !== 0)
             return false;
-        const text = node.text;
+        // Natively an identifier's text is read through its name, and a private identifier's from its field.
+        const text = node instanceof Identifier ? node.text : node.text;
         const source = this.sourceText;
         const end = node.end;
         const start = end - text.length;
@@ -614,7 +616,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 ||
@@ -658,13 +660,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)
@@ -773,7 +775,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;
     }
@@ -839,7 +844,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;
@@ -862,7 +867,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;
@@ -928,7 +933,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)
@@ -1129,39 +1134,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;
@@ -1170,62 +1175,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;
@@ -1316,7 +1321,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 */);
     }
@@ -1414,11 +1419,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)
@@ -1521,15 +1526,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);
@@ -1538,15 +1543,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 ');
@@ -1556,11 +1561,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);
@@ -1570,11 +1575,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);
@@ -1583,7 +1588,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('...');
@@ -1592,7 +1597,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 */);
@@ -1600,7 +1605,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 */);
@@ -1608,15 +1613,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('(');
@@ -1626,11 +1631,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);
@@ -1641,11 +1646,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 */);
@@ -1653,39 +1658,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 */);
@@ -1694,7 +1699,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('...');
@@ -1716,7 +1721,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 ? '}' : ']');
@@ -1822,7 +1827,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 */);
@@ -1840,7 +1845,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 */);
@@ -1889,7 +1894,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;
@@ -2150,7 +2155,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)
@@ -2248,35 +2253,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('<');
@@ -2287,77 +2292,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 */);
@@ -2366,36 +2371,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;
@@ -2449,7 +2454,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 */);
         }
@@ -2533,14 +2538,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);
@@ -2704,6 +2709,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) {
@@ -2811,15 +2820,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);
@@ -2845,7 +2858,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 */);
         }
@@ -2930,29 +2943,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);
@@ -2961,28 +2974,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);
@@ -2991,7 +3004,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);
@@ -3001,7 +3014,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);
@@ -3012,7 +3025,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);
@@ -3023,11 +3036,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);
@@ -3036,52 +3049,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;
@@ -3092,7 +3105,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;
@@ -3111,7 +3124,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;
@@ -3141,7 +3154,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;
     }
@@ -3237,7 +3250,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 */);
@@ -3269,7 +3282,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;
     }
@@ -3494,9 +3507,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) {
@@ -3557,48 +3576,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;
@@ -3713,126 +3732,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;
@@ -3858,7 +3881,7 @@ export class Printer extends NameGeneratorHost {
             this.pushCommentState(commentFreeNode, node.pos, node.end);
             this.containerPos = node.pos;
             this.containerEnd = node.end;
-            if (node.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+            if (node.kind === 263 /* SyntaxKind.VariableDeclarationList */)
                 this.declarationListContainerEnd = node.end;
             return true;
         }
@@ -3936,7 +3959,7 @@ export class Printer extends NameGeneratorHost {
     inCommentFreeRange(node) {
         const pos = node.pos;
         const end = node.end;
-        if (pos < 0 || end <= pos || node.kind === 11 /* SyntaxKind.JsxText */ || node.kind === 347 /* SyntaxKind.NotEmittedStatement */)
+        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))
@@ -4035,7 +4058,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) {
@@ -4068,12 +4091,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;
@@ -4085,7 +4108,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;
     }
@@ -4365,7 +4388,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)
@@ -4383,7 +4406,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;
     }
@@ -4519,14 +4542,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));
             }
         }
@@ -4650,17 +4673,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)
@@ -4670,11 +4693,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)
@@ -4686,24 +4709,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)
@@ -4711,26 +4734,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;