tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/transformers/visitor-base.js

@@ -149,665 +149,665 @@ function asOptionalVariableDeclaration(node) {
 export class VisitorBase extends VisitorHooks {
     visitEachChild(node) {
         switch (node.kind) {
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
                 if (node instanceof ArrayLiteralExpression)
                     return this.factory.updateArrayLiteralExpression(node, this.visitNodes(node.elements), node.multiLine);
                 break;
-            case 189 /* SyntaxKind.ArrayType */:
+            case 190 /* SyntaxKind.ArrayType */:
                 if (node instanceof ArrayTypeNode)
                     return this.factory.updateArrayTypeNode(node, required(this.visitNode(node.elementType), node.elementType));
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (node instanceof ArrowFunction)
                     return this.factory.updateArrowFunction(node, this.visitModifiers(node.modifiers), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), asOptionalToken(this.visitNode(node.equalsGreaterThanToken)), required(this.visitFunctionBody(node.body), node.body));
                 break;
-            case 235 /* SyntaxKind.AsExpression */:
+            case 236 /* SyntaxKind.AsExpression */:
                 if (node instanceof AsExpression)
                     return this.factory.updateAsExpression(node, required(this.visitNode(node.expression), node.expression), required(this.visitNode(node.type), node.type));
                 break;
-            case 224 /* SyntaxKind.AwaitExpression */:
+            case 225 /* SyntaxKind.AwaitExpression */:
                 if (node instanceof AwaitExpression)
                     return this.factory.updateAwaitExpression(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 if (node instanceof BinaryExpression)
                     return this.factory.updateBinaryExpression(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.left), node.left), this.visitNode(node.type), asToken(this.visitNode(node.operatorToken), node.operatorToken), required(this.visitNode(node.right), node.right));
                 break;
-            case 209 /* SyntaxKind.BindingElement */:
+            case 210 /* SyntaxKind.BindingElement */:
                 if (node instanceof BindingElement)
                     return this.factory.updateBindingElement(node, asOptionalToken(this.visitNode(node.dotDotDotToken)), this.visitNode(node.propertyName), this.visitNode(node.name), this.visitNode(node.initializer));
                 break;
-            case 207 /* SyntaxKind.ObjectBindingPattern */:
-            case 208 /* SyntaxKind.ArrayBindingPattern */:
+            case 208 /* SyntaxKind.ObjectBindingPattern */:
+            case 209 /* SyntaxKind.ArrayBindingPattern */:
                 if (node instanceof BindingPattern)
                     return this.factory.updateBindingPattern(node, this.visitNodes(node.elements));
                 break;
-            case 242 /* SyntaxKind.Block */:
+            case 243 /* SyntaxKind.Block */:
                 if (node instanceof Block)
                     return this.factory.updateBlock(node, this.visitNodes(node.statements), node.multiLine);
                 break;
-            case 253 /* SyntaxKind.BreakStatement */:
+            case 254 /* SyntaxKind.BreakStatement */:
                 if (node instanceof BreakStatement)
                     return this.factory.updateBreakStatement(node, asOptionalIdentifier(this.visitNode(node.label)));
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (node instanceof CallExpression)
                     return this.factory.updateCallExpression(node, required(this.visitNode(node.expression), node.expression), asOptionalToken(this.visitNode(callQuestionDotToken(node))), this.visitNodes(callTypeArguments(node)), this.visitNodes(node.arguments), node.flags);
                 break;
-            case 180 /* SyntaxKind.CallSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
                 if (node instanceof CallSignatureDeclaration)
                     return this.factory.updateCallSignatureDeclaration(node, this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 270 /* SyntaxKind.CaseBlock */:
+            case 271 /* SyntaxKind.CaseBlock */:
                 if (node instanceof CaseBlock)
                     return this.factory.updateCaseBlock(node, this.visitNodes(node.clauses));
                 break;
-            case 297 /* SyntaxKind.CaseClause */:
-            case 298 /* SyntaxKind.DefaultClause */:
+            case 298 /* SyntaxKind.CaseClause */:
+            case 299 /* SyntaxKind.DefaultClause */:
                 if (node instanceof CaseOrDefaultClause)
                     return this.factory.updateCaseOrDefaultClause(node, this.visitNode(node.expression), this.visitNodes(node.statements));
                 break;
-            case 300 /* SyntaxKind.CatchClause */:
+            case 301 /* SyntaxKind.CatchClause */:
                 if (node instanceof CatchClause)
                     return this.factory.updateCatchClause(node, asOptionalVariableDeclaration(this.visitNode(node.variableDeclaration)), asBlock(this.visitNode(node.block), node.block));
                 break;
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 if (node instanceof ClassDeclaration)
                     return this.factory.updateClassDeclaration(node, this.visitModifiers(node.modifiers), asOptionalIdentifier(this.visitNode(node.name)), this.visitNodes(node.typeParameters), this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 if (node instanceof ClassExpression)
                     return this.factory.updateClassExpression(node, this.visitModifiers(node.modifiers), asOptionalIdentifier(this.visitNode(node.name)), this.visitNodes(node.typeParameters), this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
                 break;
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 if (node instanceof ClassStaticBlockDeclaration)
                     return this.factory.updateClassStaticBlockDeclaration(node, this.visitModifiers(node.modifiers), asBlock(this.visitNode(node.body), node.body));
                 break;
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 if (node instanceof ComputedPropertyName)
                     return this.factory.updateComputedPropertyName(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 228 /* SyntaxKind.ConditionalExpression */:
+            case 229 /* SyntaxKind.ConditionalExpression */:
                 if (node instanceof ConditionalExpression)
                     return this.factory.updateConditionalExpression(node, required(this.visitNode(node.condition), node.condition), asToken(this.visitNode(node.questionToken), node.questionToken), required(this.visitNode(node.whenTrue), node.whenTrue), asToken(this.visitNode(node.colonToken), node.colonToken), required(this.visitNode(node.whenFalse), node.whenFalse));
                 break;
-            case 195 /* SyntaxKind.ConditionalType */:
+            case 196 /* SyntaxKind.ConditionalType */:
                 if (node instanceof ConditionalTypeNode)
                     return this.factory.updateConditionalTypeNode(node, required(this.visitNode(node.checkType), node.checkType), required(this.visitNode(node.extendsType), node.extendsType), required(this.visitNode(node.trueType), node.trueType), required(this.visitNode(node.falseType), node.falseType));
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (node instanceof ConstructorDeclaration)
                     return this.factory.updateConstructorDeclaration(node, this.visitModifiers(node.modifiers), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitFunctionBody(node.body));
                 break;
-            case 186 /* SyntaxKind.ConstructorType */:
+            case 187 /* SyntaxKind.ConstructorType */:
                 if (node instanceof ConstructorTypeNode)
                     return this.factory.updateConstructorTypeNode(node, this.visitModifiers(node.modifiers), this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 181 /* SyntaxKind.ConstructSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
                 if (node instanceof ConstructSignatureDeclaration)
                     return this.factory.updateConstructSignatureDeclaration(node, this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 252 /* SyntaxKind.ContinueStatement */:
+            case 253 /* SyntaxKind.ContinueStatement */:
                 if (node instanceof ContinueStatement)
                     return this.factory.updateContinueStatement(node, asOptionalIdentifier(this.visitNode(node.label)));
                 break;
-            case 171 /* SyntaxKind.Decorator */:
+            case 172 /* SyntaxKind.Decorator */:
                 if (node instanceof Decorator)
                     return this.factory.updateDecorator(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 221 /* SyntaxKind.DeleteExpression */:
+            case 222 /* SyntaxKind.DeleteExpression */:
                 if (node instanceof DeleteExpression)
                     return this.factory.updateDeleteExpression(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 247 /* SyntaxKind.DoStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
                 if (node instanceof DoStatement)
                     return this.factory.updateDoStatement(node, required(this.visitIterationBody(node.statement), node.statement), required(this.visitNode(node.expression), node.expression));
                 break;
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if (node instanceof ElementAccessExpression)
                     return this.factory.updateElementAccessExpression(node, required(this.visitNode(node.expression), node.expression), asOptionalToken(this.visitNode(node.questionDotToken)), required(this.visitNode(node.argumentExpression), node.argumentExpression), node.flags);
                 break;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (node instanceof EnumDeclaration)
                     return this.factory.updateEnumDeclaration(node, this.visitModifiers(node.modifiers), asIdentifier(this.visitNode(node.name), node.name), this.visitNodes(node.members));
                 break;
-            case 306 /* SyntaxKind.EnumMember */:
+            case 307 /* SyntaxKind.EnumMember */:
                 if (node instanceof EnumMember)
                     return this.factory.updateEnumMember(node, required(this.visitNode(node.name), node.name), this.visitNode(node.initializer));
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment)
                     return this.factory.updateExportAssignment(node, this.visitModifiers(node.modifiers), node.isExportEquals, this.visitNode(node.type), required(this.visitNode(node.expression), node.expression));
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (node instanceof ExportDeclaration)
                     return this.factory.updateExportDeclaration(node, this.visitModifiers(node.modifiers), node.isTypeOnly, this.visitNode(node.exportClause), this.visitNode(node.moduleSpecifier), asOptionalImportAttributes(this.visitNode(node.attributes)));
                 break;
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 if (node instanceof ExportSpecifier)
                     return this.factory.updateExportSpecifier(node, node.isTypeOnly, this.visitNode(node.propertyName), required(this.visitNode(node.name), node.name));
                 break;
-            case 245 /* SyntaxKind.ExpressionStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 if (node instanceof ExpressionStatement)
                     return this.factory.updateExpressionStatement(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
                 if (node instanceof ExpressionWithTypeArguments)
                     return this.factory.updateExpressionWithTypeArguments(node, required(this.visitNode(node.expression), node.expression), this.visitNodes(node.typeArguments));
                 break;
-            case 284 /* SyntaxKind.ExternalModuleReference */:
+            case 285 /* SyntaxKind.ExternalModuleReference */:
                 if (node instanceof ExternalModuleReference)
                     return this.factory.updateExternalModuleReference(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 if (node instanceof ForInOrOfStatement)
                     return this.factory.updateForInOrOfStatement(node, asOptionalToken(this.visitNode(node.awaitModifier)), required(this.visitNode(node.initializer), node.initializer), required(this.visitNode(node.expression), node.expression), required(this.visitIterationBody(node.statement), node.statement));
                 break;
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 if (node instanceof ForStatement)
                     return this.factory.updateForStatement(node, this.visitNode(node.initializer), this.visitNode(node.condition), this.visitNode(node.incrementor), required(this.visitIterationBody(node.statement), node.statement));
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 if (node instanceof FunctionDeclaration)
                     return this.factory.updateFunctionDeclaration(node, this.visitModifiers(node.modifiers), asOptionalToken(this.visitNode(node.asteriskToken)), asOptionalIdentifier(this.visitNode(node.name)), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitFunctionBody(node.body));
                 break;
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 if (node instanceof FunctionExpression)
                     return this.factory.updateFunctionExpression(node, this.visitModifiers(node.modifiers), asOptionalToken(this.visitNode(node.asteriskToken)), asOptionalIdentifier(this.visitNode(node.name)), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), required(this.visitFunctionBody(node.body), node.body));
                 break;
-            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.FunctionType */:
                 if (node instanceof FunctionTypeNode)
                     return this.factory.updateFunctionTypeNode(node, this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration)
                     return this.factory.updateGetAccessorDeclaration(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.name), node.name), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitFunctionBody(node.body));
                 break;
-            case 299 /* SyntaxKind.HeritageClause */:
+            case 300 /* SyntaxKind.HeritageClause */:
                 if (node instanceof HeritageClause)
                     return this.factory.updateHeritageClause(node, node.token, this.visitNodes(node.types));
                 break;
-            case 246 /* SyntaxKind.IfStatement */:
+            case 247 /* SyntaxKind.IfStatement */:
                 if (node instanceof IfStatement)
                     return this.factory.updateIfStatement(node, required(this.visitNode(node.expression), node.expression), required(this.visitEmbeddedStatement(node.thenStatement), node.thenStatement), this.visitEmbeddedStatement(node.elseStatement));
                 break;
-            case 302 /* SyntaxKind.ImportAttribute */:
+            case 303 /* SyntaxKind.ImportAttribute */:
                 if (node instanceof ImportAttribute)
                     return this.factory.updateImportAttribute(node, this.visitNode(node.name), required(this.visitNode(node.value), node.value));
                 break;
-            case 301 /* SyntaxKind.ImportAttributes */:
+            case 302 /* SyntaxKind.ImportAttributes */:
                 if (node instanceof ImportAttributes)
                     return this.factory.updateImportAttributes(node, node.token, this.visitNodes(node.attributes), node.multiLine);
                 break;
-            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.ImportClause */:
                 if (node instanceof ImportClause)
                     return this.factory.updateImportClause(node, node.phaseModifier, asOptionalIdentifier(this.visitNode(node.name)), this.visitNode(node.namedBindings));
                 break;
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
                 if (node instanceof ImportDeclaration)
                     return this.factory.updateImportDeclaration(node, this.visitModifiers(node.modifiers), asOptionalImportClause(this.visitNode(node.importClause)), required(this.visitNode(node.moduleSpecifier), node.moduleSpecifier), asOptionalImportAttributes(this.visitNode(node.attributes)));
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (node instanceof ImportEqualsDeclaration)
                     return this.factory.updateImportEqualsDeclaration(node, this.visitModifiers(node.modifiers), node.isTypeOnly, asIdentifier(this.visitNode(node.name), node.name), required(this.visitNode(node.moduleReference), node.moduleReference));
                 break;
-            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
                 if (node instanceof ImportSpecifier)
                     return this.factory.updateImportSpecifier(node, node.isTypeOnly, this.visitNode(node.propertyName), asIdentifier(this.visitNode(node.name), node.name));
                 break;
-            case 206 /* SyntaxKind.ImportType */:
+            case 207 /* SyntaxKind.ImportType */:
                 if (node instanceof ImportTypeNode)
                     return this.factory.updateImportTypeNode(node, node.isTypeOf, required(this.visitNode(node.argument), node.argument), asOptionalImportAttributes(this.visitNode(node.attributes)), this.visitNode(node.qualifier), this.visitNodes(node.typeArguments));
                 break;
-            case 200 /* SyntaxKind.IndexedAccessType */:
+            case 201 /* SyntaxKind.IndexedAccessType */:
                 if (node instanceof IndexedAccessTypeNode)
                     return this.factory.updateIndexedAccessTypeNode(node, required(this.visitNode(node.objectType), node.objectType), required(this.visitNode(node.indexType), node.indexType));
                 break;
-            case 182 /* SyntaxKind.IndexSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
                 if (node instanceof IndexSignatureDeclaration)
                     return this.factory.updateIndexSignatureDeclaration(node, this.visitModifiers(node.modifiers), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 196 /* SyntaxKind.InferType */:
+            case 197 /* SyntaxKind.InferType */:
                 if (node instanceof InferTypeNode)
                     return this.factory.updateInferTypeNode(node, asTypeParameterDeclaration(this.visitNode(node.typeParameter), node.typeParameter));
                 break;
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
                 if (node instanceof InterfaceDeclaration)
                     return this.factory.updateInterfaceDeclaration(node, this.visitModifiers(node.modifiers), asIdentifier(this.visitNode(node.name), node.name), this.visitNodes(node.typeParameters), this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
                 break;
-            case 194 /* SyntaxKind.IntersectionType */:
+            case 195 /* SyntaxKind.IntersectionType */:
                 if (node instanceof IntersectionTypeNode)
                     return this.factory.updateIntersectionTypeNode(node, this.visitNodes(node.types));
                 break;
-            case 315 /* SyntaxKind.JSDoc */:
+            case 316 /* SyntaxKind.JSDoc */:
                 if (node instanceof JSDoc)
                     return this.factory.updateJSDoc(node, this.visitNodes(node.comment), this.visitNodes(node.tags));
                 break;
-            case 323 /* SyntaxKind.JSDocAugmentsTag */:
+            case 324 /* SyntaxKind.JSDocAugmentsTag */:
                 if (node instanceof JSDocAugmentsTag)
                     return this.factory.updateJSDocAugmentsTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), asExpressionWithTypeArguments(this.visitNode(node.className), node.className), this.visitNodes(node.comment));
                 break;
-            case 331 /* SyntaxKind.JSDocCallbackTag */:
+            case 332 /* SyntaxKind.JSDocCallbackTag */:
                 if (node instanceof JSDocCallbackTag)
                     return this.factory.updateJSDocCallbackTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), required(this.visitNode(node.typeExpression), node.typeExpression), this.visitNode(node.name), this.visitNodes(node.comment));
                 break;
-            case 325 /* SyntaxKind.JSDocDeprecatedTag */:
+            case 326 /* SyntaxKind.JSDocDeprecatedTag */:
                 if (node instanceof JSDocDeprecatedTag)
                     return this.factory.updateJSDocDeprecatedTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 324 /* SyntaxKind.JSDocImplementsTag */:
+            case 325 /* SyntaxKind.JSDocImplementsTag */:
                 if (node instanceof JSDocImplementsTag)
                     return this.factory.updateJSDocImplementsTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), asExpressionWithTypeArguments(this.visitNode(node.className), node.className), this.visitNodes(node.comment));
                 break;
-            case 343 /* SyntaxKind.JSDocImportTag */:
+            case 344 /* SyntaxKind.JSDocImportTag */:
                 if (node instanceof JSDocImportTag)
                     return this.factory.updateJSDocImportTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), asOptionalImportClause(this.visitNode(node.importClause)), required(this.visitNode(node.moduleSpecifier), node.moduleSpecifier), asOptionalImportAttributes(this.visitNode(node.attributes)), this.visitNodes(node.comment));
                 break;
-            case 319 /* SyntaxKind.JSDocLink */:
+            case 320 /* SyntaxKind.JSDocLink */:
                 if (node instanceof JSDocLink)
                     return this.factory.updateJSDocLink(node, this.visitNode(node.name), node.text);
                 break;
-            case 320 /* SyntaxKind.JSDocLinkCode */:
+            case 321 /* SyntaxKind.JSDocLinkCode */:
                 if (node instanceof JSDocLinkCode)
                     return this.factory.updateJSDocLinkCode(node, this.visitNode(node.name), node.text);
                 break;
-            case 321 /* SyntaxKind.JSDocLinkPlain */:
+            case 322 /* SyntaxKind.JSDocLinkPlain */:
                 if (node instanceof JSDocLinkPlain)
                     return this.factory.updateJSDocLinkPlain(node, this.visitNode(node.name), node.text);
                 break;
-            case 309 /* SyntaxKind.JSDocNameReference */:
+            case 310 /* SyntaxKind.JSDocNameReference */:
                 if (node instanceof JSDocNameReference)
                     return this.factory.updateJSDocNameReference(node, this.visitNode(node.name));
                 break;
-            case 312 /* SyntaxKind.JSDocNonNullableType */:
+            case 313 /* SyntaxKind.JSDocNonNullableType */:
                 if (node instanceof JSDocNonNullableType)
                     return this.factory.updateJSDocNonNullableType(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 311 /* SyntaxKind.JSDocNullableType */:
+            case 312 /* SyntaxKind.JSDocNullableType */:
                 if (node instanceof JSDocNullableType)
                     return this.factory.updateJSDocNullableType(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 313 /* SyntaxKind.JSDocOptionalType */:
+            case 314 /* SyntaxKind.JSDocOptionalType */:
                 if (node instanceof JSDocOptionalType)
                     return this.factory.updateJSDocOptionalType(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 332 /* SyntaxKind.JSDocOverloadTag */:
+            case 333 /* SyntaxKind.JSDocOverloadTag */:
                 if (node instanceof JSDocOverloadTag)
                     return this.factory.updateJSDocOverloadTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), required(this.visitNode(node.typeExpression), node.typeExpression), this.visitNodes(node.comment));
                 break;
-            case 330 /* SyntaxKind.JSDocOverrideTag */:
+            case 331 /* SyntaxKind.JSDocOverrideTag */:
                 if (node instanceof JSDocOverrideTag)
                     return this.factory.updateJSDocOverrideTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 333 /* SyntaxKind.JSDocParameterTag */:
-            case 340 /* SyntaxKind.JSDocPropertyTag */:
+            case 334 /* SyntaxKind.JSDocParameterTag */:
+            case 341 /* SyntaxKind.JSDocPropertyTag */:
                 if (node instanceof JSDocParameterOrPropertyTag)
                     return this.factory.updateJSDocParameterOrPropertyTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), required(this.visitNode(node.name), node.name), node.isBracketed, this.visitNode(node.typeExpression), node.isNameFirst, this.visitNodes(node.comment));
                 break;
-            case 327 /* SyntaxKind.JSDocPrivateTag */:
+            case 328 /* SyntaxKind.JSDocPrivateTag */:
                 if (node instanceof JSDocPrivateTag)
                     return this.factory.updateJSDocPrivateTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 328 /* SyntaxKind.JSDocProtectedTag */:
+            case 329 /* SyntaxKind.JSDocProtectedTag */:
                 if (node instanceof JSDocProtectedTag)
                     return this.factory.updateJSDocProtectedTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 326 /* SyntaxKind.JSDocPublicTag */:
+            case 327 /* SyntaxKind.JSDocPublicTag */:
                 if (node instanceof JSDocPublicTag)
                     return this.factory.updateJSDocPublicTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 329 /* SyntaxKind.JSDocReadonlyTag */:
+            case 330 /* SyntaxKind.JSDocReadonlyTag */:
                 if (node instanceof JSDocReadonlyTag)
                     return this.factory.updateJSDocReadonlyTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 334 /* SyntaxKind.JSDocReturnTag */:
+            case 335 /* SyntaxKind.JSDocReturnTag */:
                 if (node instanceof JSDocReturnTag)
                     return this.factory.updateJSDocReturnTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNode(node.typeExpression), this.visitNodes(node.comment));
                 break;
-            case 342 /* SyntaxKind.JSDocSatisfiesTag */:
+            case 343 /* SyntaxKind.JSDocSatisfiesTag */:
                 if (node instanceof JSDocSatisfiesTag)
                     return this.factory.updateJSDocSatisfiesTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), required(this.visitNode(node.typeExpression), node.typeExpression), this.visitNodes(node.comment));
                 break;
-            case 339 /* SyntaxKind.JSDocSeeTag */:
+            case 340 /* SyntaxKind.JSDocSeeTag */:
                 if (node instanceof JSDocSeeTag)
                     return this.factory.updateJSDocSeeTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNode(node.nameExpression), this.visitNodes(node.comment));
                 break;
-            case 318 /* SyntaxKind.JSDocSignature */:
+            case 319 /* SyntaxKind.JSDocSignature */:
                 if (node instanceof JSDocSignature)
                     return this.factory.updateJSDocSignature(node, this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 337 /* SyntaxKind.JSDocTemplateTag */:
+            case 338 /* SyntaxKind.JSDocTemplateTag */:
                 if (node instanceof JSDocTemplateTag)
                     return this.factory.updateJSDocTemplateTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNode(node.constraint), this.visitNodes(node.typeParameters), this.visitNodes(node.comment));
                 break;
-            case 335 /* SyntaxKind.JSDocThisTag */:
+            case 336 /* SyntaxKind.JSDocThisTag */:
                 if (node instanceof JSDocThisTag)
                     return this.factory.updateJSDocThisTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), required(this.visitNode(node.typeExpression), node.typeExpression), this.visitNodes(node.comment));
                 break;
-            case 341 /* SyntaxKind.JSDocThrowsTag */:
+            case 342 /* SyntaxKind.JSDocThrowsTag */:
                 if (node instanceof JSDocThrowsTag)
                     return this.factory.updateJSDocThrowsTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNode(node.typeExpression), this.visitNodes(node.comment));
                 break;
-            case 338 /* SyntaxKind.JSDocTypedefTag */:
+            case 339 /* SyntaxKind.JSDocTypedefTag */:
                 if (node instanceof JSDocTypedefTag)
                     return this.factory.updateJSDocTypedefTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNode(node.typeExpression), this.visitNode(node.name), this.visitNodes(node.comment));
                 break;
-            case 308 /* SyntaxKind.JSDocTypeExpression */:
+            case 309 /* SyntaxKind.JSDocTypeExpression */:
                 if (node instanceof JSDocTypeExpression)
                     return this.factory.updateJSDocTypeExpression(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 336 /* SyntaxKind.JSDocTypeTag */:
+            case 337 /* SyntaxKind.JSDocTypeTag */:
                 if (node instanceof JSDocTypeTag)
                     return this.factory.updateJSDocTypeTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), required(this.visitNode(node.typeExpression), node.typeExpression), this.visitNodes(node.comment));
                 break;
-            case 322 /* SyntaxKind.JSDocUnknownTag */:
+            case 323 /* SyntaxKind.JSDocUnknownTag */:
                 if (node instanceof JSDocUnknownTag)
                     return this.factory.updateJSDocUnknownTag(node, asIdentifier(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.comment));
                 break;
-            case 314 /* SyntaxKind.JSDocVariadicType */:
+            case 315 /* SyntaxKind.JSDocVariadicType */:
                 if (node instanceof JSDocVariadicType)
                     return this.factory.updateJSDocVariadicType(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 292 /* SyntaxKind.JsxAttribute */:
+            case 293 /* SyntaxKind.JsxAttribute */:
                 if (node instanceof JsxAttribute)
                     return this.factory.updateJsxAttribute(node, required(this.visitNode(node.name), node.name), this.visitNode(node.initializer));
                 break;
-            case 293 /* SyntaxKind.JsxAttributes */:
+            case 294 /* SyntaxKind.JsxAttributes */:
                 if (node instanceof JsxAttributes)
                     return this.factory.updateJsxAttributes(node, this.visitNodes(node.properties));
                 break;
-            case 288 /* SyntaxKind.JsxClosingElement */:
+            case 289 /* SyntaxKind.JsxClosingElement */:
                 if (node instanceof JsxClosingElement)
                     return this.factory.updateJsxClosingElement(node, required(this.visitNode(node.tagName), node.tagName));
                 break;
-            case 285 /* SyntaxKind.JsxElement */:
+            case 286 /* SyntaxKind.JsxElement */:
                 if (node instanceof JsxElement)
                     return this.factory.updateJsxElement(node, asJsxOpeningElement(this.visitNode(node.openingElement), node.openingElement), this.visitNodes(node.children), asJsxClosingElement(this.visitNode(node.closingElement), node.closingElement));
                 break;
-            case 295 /* SyntaxKind.JsxExpression */:
+            case 296 /* SyntaxKind.JsxExpression */:
                 if (node instanceof JsxExpression)
                     return this.factory.updateJsxExpression(node, asOptionalToken(this.visitNode(node.dotDotDotToken)), this.visitNode(node.expression));
                 break;
-            case 289 /* SyntaxKind.JsxFragment */:
+            case 290 /* SyntaxKind.JsxFragment */:
                 if (node instanceof JsxFragment)
                     return this.factory.updateJsxFragment(node, asJsxOpeningFragment(this.visitNode(node.openingFragment), node.openingFragment), this.visitNodes(node.children), asJsxClosingFragment(this.visitNode(node.closingFragment), node.closingFragment));
                 break;
-            case 296 /* SyntaxKind.JsxNamespacedName */:
+            case 297 /* SyntaxKind.JsxNamespacedName */:
                 if (node instanceof JsxNamespacedName)
                     return this.factory.updateJsxNamespacedName(node, asIdentifier(this.visitNode(node.namespace), node.namespace), asIdentifier(this.visitNode(node.name), node.name));
                 break;
-            case 287 /* SyntaxKind.JsxOpeningElement */:
+            case 288 /* SyntaxKind.JsxOpeningElement */:
                 if (node instanceof JsxOpeningElement)
                     return this.factory.updateJsxOpeningElement(node, required(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.typeArguments), asJsxAttributes(this.visitNode(node.attributes), node.attributes));
                 break;
-            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            case 287 /* SyntaxKind.JsxSelfClosingElement */:
                 if (node instanceof JsxSelfClosingElement)
                     return this.factory.updateJsxSelfClosingElement(node, required(this.visitNode(node.tagName), node.tagName), this.visitNodes(node.typeArguments), asJsxAttributes(this.visitNode(node.attributes), node.attributes));
                 break;
-            case 294 /* SyntaxKind.JsxSpreadAttribute */:
+            case 295 /* SyntaxKind.JsxSpreadAttribute */:
                 if (node instanceof JsxSpreadAttribute)
                     return this.factory.updateJsxSpreadAttribute(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 257 /* SyntaxKind.LabeledStatement */:
+            case 258 /* SyntaxKind.LabeledStatement */:
                 if (node instanceof LabeledStatement)
                     return this.factory.updateLabeledStatement(node, asIdentifier(this.visitNode(node.label), node.label), required(this.visitEmbeddedStatement(node.statement), node.statement));
                 break;
-            case 202 /* SyntaxKind.LiteralType */:
+            case 203 /* SyntaxKind.LiteralType */:
                 if (node instanceof LiteralTypeNode)
                     return this.factory.updateLiteralTypeNode(node, required(this.visitNode(node.literal), node.literal));
                 break;
-            case 201 /* SyntaxKind.MappedType */:
+            case 202 /* SyntaxKind.MappedType */:
                 if (node instanceof MappedTypeNode)
                     return this.factory.updateMappedTypeNode(node, asOptionalToken(this.visitNode(node.readonlyToken)), asTypeParameterDeclaration(this.visitNode(node.typeParameter), node.typeParameter), this.visitNode(node.nameType), asOptionalToken(this.visitNode(node.questionToken)), this.visitNode(node.type), this.visitNodes(node.members));
                 break;
-            case 237 /* SyntaxKind.MetaProperty */:
+            case 238 /* SyntaxKind.MetaProperty */:
                 if (node instanceof MetaProperty)
                     return this.factory.updateMetaProperty(node, node.keywordToken, asIdentifier(this.visitNode(node.name), node.name));
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration)
                     return this.factory.updateMethodDeclaration(node, this.visitModifiers(node.modifiers), asOptionalToken(this.visitNode(node.asteriskToken)), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.postfixToken)), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitFunctionBody(node.body));
                 break;
-            case 174 /* SyntaxKind.MethodSignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
                 if (node instanceof MethodSignatureDeclaration)
                     return this.factory.updateMethodSignatureDeclaration(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.postfixToken)), this.visitNodes(node.typeParameters), this.visitNodes(node.parameters), this.visitNode(node.type));
                 break;
-            case 283 /* SyntaxKind.MissingDeclaration */:
+            case 284 /* SyntaxKind.MissingDeclaration */:
                 if (node instanceof MissingDeclaration)
                     return this.factory.updateMissingDeclaration(node, this.visitModifiers(node.modifiers));
                 break;
-            case 269 /* SyntaxKind.ModuleBlock */:
+            case 270 /* SyntaxKind.ModuleBlock */:
                 if (node instanceof ModuleBlock)
                     return this.factory.updateModuleBlock(node, this.visitNodes(node.statements));
                 break;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (node instanceof ModuleDeclaration)
-                    return this.factory.updateModuleDeclaration(node, this.visitModifiers(node.modifiers), node.keyword, required(this.visitNode(node.name), node.name), this.visitNode(node.body));
+                    return this.factory.updateModuleDeclaration(node, this.visitModifiers(node.modifiers), node.keyword, required(this.visitNode(node.name), node.name), this.visitNode(node.attributes), this.visitNode(node.body));
                 break;
-            case 280 /* SyntaxKind.NamedExports */:
+            case 281 /* SyntaxKind.NamedExports */:
                 if (node instanceof NamedExports)
                     return this.factory.updateNamedExports(node, this.visitNodes(node.elements));
                 break;
-            case 276 /* SyntaxKind.NamedImports */:
+            case 277 /* SyntaxKind.NamedImports */:
                 if (node instanceof NamedImports)
                     return this.factory.updateNamedImports(node, this.visitNodes(node.elements));
                 break;
-            case 203 /* SyntaxKind.NamedTupleMember */:
+            case 204 /* SyntaxKind.NamedTupleMember */:
                 if (node instanceof NamedTupleMember)
                     return this.factory.updateNamedTupleMember(node, asOptionalToken(this.visitNode(node.dotDotDotToken)), asIdentifier(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.questionToken)), required(this.visitNode(node.type), node.type));
                 break;
-            case 281 /* SyntaxKind.NamespaceExport */:
+            case 282 /* SyntaxKind.NamespaceExport */:
                 if (node instanceof NamespaceExport)
                     return this.factory.updateNamespaceExport(node, required(this.visitNode(node.name), node.name));
                 break;
-            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            case 272 /* SyntaxKind.NamespaceExportDeclaration */:
                 if (node instanceof NamespaceExportDeclaration)
                     return this.factory.updateNamespaceExportDeclaration(node, this.visitModifiers(node.modifiers), asIdentifier(this.visitNode(node.name), node.name));
                 break;
-            case 275 /* SyntaxKind.NamespaceImport */:
+            case 276 /* SyntaxKind.NamespaceImport */:
                 if (node instanceof NamespaceImport)
                     return this.factory.updateNamespaceImport(node, asIdentifier(this.visitNode(node.name), node.name));
                 break;
-            case 215 /* SyntaxKind.NewExpression */:
+            case 216 /* SyntaxKind.NewExpression */:
                 if (node instanceof NewExpression)
                     return this.factory.updateNewExpression(node, required(this.visitNode(node.expression), node.expression), this.visitNodes(node.typeArguments), this.visitNodes(node.arguments));
                 break;
-            case 236 /* SyntaxKind.NonNullExpression */:
+            case 237 /* SyntaxKind.NonNullExpression */:
                 if (node instanceof NonNullExpression)
                     return this.factory.updateNonNullExpression(node, required(this.visitNode(node.expression), node.expression), node.flags);
                 break;
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 212 /* SyntaxKind.ObjectLiteralExpression */:
                 if (node instanceof ObjectLiteralExpression)
                     return this.factory.updateObjectLiteralExpression(node, this.visitNodes(node.properties), node.multiLine);
                 break;
-            case 191 /* SyntaxKind.OptionalType */:
+            case 192 /* SyntaxKind.OptionalType */:
                 if (node instanceof OptionalTypeNode)
                     return this.factory.updateOptionalTypeNode(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (node instanceof ParameterDeclaration)
                     return this.factory.updateParameterDeclaration(node, this.visitModifiers(node.modifiers), asOptionalToken(this.visitNode(node.dotDotDotToken)), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.questionToken)), this.visitNode(node.type), this.visitNode(node.initializer));
                 break;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 if (node instanceof ParenthesizedExpression)
                     return this.factory.updateParenthesizedExpression(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 197 /* SyntaxKind.ParenthesizedType */:
+            case 198 /* SyntaxKind.ParenthesizedType */:
                 if (node instanceof ParenthesizedTypeNode)
                     return this.factory.updateParenthesizedTypeNode(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            case 349 /* SyntaxKind.PartiallyEmittedExpression */:
                 if (node instanceof PartiallyEmittedExpression)
                     return this.factory.updatePartiallyEmittedExpression(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            case 227 /* SyntaxKind.PostfixUnaryExpression */:
                 if (node instanceof PostfixUnaryExpression)
                     return this.factory.updatePostfixUnaryExpression(node, required(this.visitNode(node.operand), node.operand), node.operator);
                 break;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
                 if (node instanceof PrefixUnaryExpression)
                     return this.factory.updatePrefixUnaryExpression(node, node.operator, required(this.visitNode(node.operand), node.operand));
                 break;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 if (node instanceof PropertyAccessExpression)
                     return this.factory.updatePropertyAccessExpression(node, required(this.visitNode(node.expression), node.expression), asOptionalToken(this.visitNode(node.questionDotToken)), required(this.visitNode(node.name), node.name), node.flags);
                 break;
-            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
                 if (node instanceof PropertyAssignment)
                     return this.factory.updatePropertyAssignment(node, this.visitModifiers(propertyAssignmentModifiers(node)), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(propertyAssignmentPostfixToken(node))), this.visitNode(propertyAssignmentType(node)), required(this.visitNode(node.initializer), node.initializer));
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (node instanceof PropertyDeclaration)
                     return this.factory.updatePropertyDeclaration(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.postfixToken)), this.visitNode(node.type), this.visitNode(node.initializer));
                 break;
-            case 172 /* SyntaxKind.PropertySignature */:
+            case 173 /* SyntaxKind.PropertySignature */:
                 if (node instanceof PropertySignatureDeclaration)
                     return this.factory.updatePropertySignatureDeclaration(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.postfixToken)), this.visitNode(node.type), this.visitNode(node.initializer));
                 break;
-            case 167 /* SyntaxKind.QualifiedName */:
+            case 168 /* SyntaxKind.QualifiedName */:
                 if (node instanceof QualifiedName)
-                    return this.factory.updateQualifiedName(node, required(this.visitNode(node.left), node.left), asIdentifier(this.visitNode(node.right), node.right));
+                    return this.factory.updateQualifiedName(node, required(this.visitNode(node.left), node.left), required(this.visitNode(node.right), node.right));
                 break;
-            case 192 /* SyntaxKind.RestType */:
+            case 193 /* SyntaxKind.RestType */:
                 if (node instanceof RestTypeNode)
                     return this.factory.updateRestTypeNode(node, required(this.visitNode(node.type), node.type));
                 break;
-            case 254 /* SyntaxKind.ReturnStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
                 if (node instanceof ReturnStatement)
                     return this.factory.updateReturnStatement(node, this.visitNode(node.expression));
                 break;
-            case 239 /* SyntaxKind.SatisfiesExpression */:
+            case 240 /* SyntaxKind.SatisfiesExpression */:
                 if (node instanceof SatisfiesExpression)
                     return this.factory.updateSatisfiesExpression(node, required(this.visitNode(node.expression), node.expression), required(this.visitNode(node.type), node.type));
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration)
                     return this.factory.updateSetAccessorDeclaration(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.name), node.name), this.visitNodes(node.typeParameters), this.visitParameters(node.parameters), this.visitNode(node.type), this.visitNode(node.fullSignature), this.visitFunctionBody(node.body));
                 break;
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 if (node instanceof ShorthandPropertyAssignment)
                     return this.factory.updateShorthandPropertyAssignment(node, this.visitModifiers(node.modifiers), required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.postfixToken)), this.visitNode(node.type), asOptionalToken(this.visitNode(node.equalsToken)), this.visitNode(node.objectAssignmentInitializer));
                 break;
-            case 305 /* SyntaxKind.SpreadAssignment */:
+            case 306 /* SyntaxKind.SpreadAssignment */:
                 if (node instanceof SpreadAssignment)
                     return this.factory.updateSpreadAssignment(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 231 /* SyntaxKind.SpreadElement */:
+            case 232 /* SyntaxKind.SpreadElement */:
                 if (node instanceof SpreadElement)
                     return this.factory.updateSpreadElement(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 256 /* SyntaxKind.SwitchStatement */:
+            case 257 /* SyntaxKind.SwitchStatement */:
                 if (node instanceof SwitchStatement)
                     return this.factory.updateSwitchStatement(node, required(this.visitNode(node.expression), node.expression), asCaseBlock(this.visitNode(node.caseBlock), node.caseBlock));
                 break;
-            case 349 /* SyntaxKind.SyntheticReferenceExpression */:
+            case 350 /* SyntaxKind.SyntheticReferenceExpression */:
                 if (node instanceof SyntheticReferenceExpression)
                     return this.factory.updateSyntheticReferenceExpression(node, required(this.visitNode(node.expression), node.expression), required(this.visitNode(node.thisArg), node.thisArg));
                 break;
-            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            case 217 /* SyntaxKind.TaggedTemplateExpression */:
                 if (node instanceof TaggedTemplateExpression)
                     return this.factory.updateTaggedTemplateExpression(node, required(this.visitNode(node.tag), node.tag), asOptionalToken(this.visitNode(node.questionDotToken)), this.visitNodes(node.typeArguments), required(this.visitNode(node.template), node.template), node.flags);
                 break;
-            case 229 /* SyntaxKind.TemplateExpression */:
+            case 230 /* SyntaxKind.TemplateExpression */:
                 if (node instanceof TemplateExpression)
                     return this.factory.updateTemplateExpression(node, asTemplateHead(this.visitNode(node.head), node.head), this.visitNodes(node.templateSpans));
                 break;
-            case 204 /* SyntaxKind.TemplateLiteralType */:
+            case 205 /* SyntaxKind.TemplateLiteralType */:
                 if (node instanceof TemplateLiteralTypeNode)
                     return this.factory.updateTemplateLiteralTypeNode(node, asTemplateHead(this.visitNode(node.head), node.head), this.visitNodes(node.templateSpans));
                 break;
-            case 205 /* SyntaxKind.TemplateLiteralTypeSpan */:
+            case 206 /* SyntaxKind.TemplateLiteralTypeSpan */:
                 if (node instanceof TemplateLiteralTypeSpan)
                     return this.factory.updateTemplateLiteralTypeSpan(node, required(this.visitNode(node.type), node.type), required(this.visitNode(node.literal), node.literal));
                 break;
-            case 240 /* SyntaxKind.TemplateSpan */:
+            case 241 /* SyntaxKind.TemplateSpan */:
                 if (node instanceof TemplateSpan)
                     return this.factory.updateTemplateSpan(node, required(this.visitNode(node.expression), node.expression), required(this.visitNode(node.literal), node.literal));
                 break;
-            case 258 /* SyntaxKind.ThrowStatement */:
+            case 259 /* SyntaxKind.ThrowStatement */:
                 if (node instanceof ThrowStatement)
                     return this.factory.updateThrowStatement(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 259 /* SyntaxKind.TryStatement */:
+            case 260 /* SyntaxKind.TryStatement */:
                 if (node instanceof TryStatement)
                     return this.factory.updateTryStatement(node, asBlock(this.visitNode(node.tryBlock), node.tryBlock), asOptionalCatchClause(this.visitNode(node.catchClause)), asOptionalBlock(this.visitNode(node.finallyBlock)));
                 break;
-            case 190 /* SyntaxKind.TupleType */:
+            case 191 /* SyntaxKind.TupleType */:
                 if (node instanceof TupleTypeNode)
                     return this.factory.updateTupleTypeNode(node, this.visitNodes(node.elements));
                 break;
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 if (node instanceof TypeAliasDeclaration)
                     return this.factory.updateTypeAliasDeclaration(node, this.visitModifiers(node.modifiers), asIdentifier(this.visitNode(node.name), node.name), this.visitNodes(node.typeParameters), required(this.visitNode(node.type), node.type));
                 break;
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
                 if (node instanceof TypeAssertion)
                     return this.factory.updateTypeAssertion(node, required(this.visitNode(node.type), node.type), required(this.visitNode(node.expression), node.expression));
                 break;
-            case 188 /* SyntaxKind.TypeLiteral */:
+            case 189 /* SyntaxKind.TypeLiteral */:
                 if (node instanceof TypeLiteralNode)
                     return this.factory.updateTypeLiteralNode(node, this.visitNodes(node.members));
                 break;
-            case 222 /* SyntaxKind.TypeOfExpression */:
+            case 223 /* SyntaxKind.TypeOfExpression */:
                 if (node instanceof TypeOfExpression)
                     return this.factory.updateTypeOfExpression(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 199 /* SyntaxKind.TypeOperator */:
+            case 200 /* SyntaxKind.TypeOperator */:
                 if (node instanceof TypeOperatorNode)
                     return this.factory.updateTypeOperatorNode(node, node.operator, required(this.visitNode(node.type), node.type));
                 break;
-            case 169 /* SyntaxKind.TypeParameter */:
+            case 170 /* SyntaxKind.TypeParameter */:
                 if (node instanceof TypeParameterDeclaration)
                     return this.factory.updateTypeParameterDeclaration(node, this.visitModifiers(node.modifiers), asIdentifier(this.visitNode(node.name), node.name), this.visitNode(node.constraint), this.visitNode(node.expression), this.visitNode(node.defaultType));
                 break;
-            case 183 /* SyntaxKind.TypePredicate */:
+            case 184 /* SyntaxKind.TypePredicate */:
                 if (node instanceof TypePredicateNode)
                     return this.factory.updateTypePredicateNode(node, asOptionalToken(this.visitNode(node.assertsModifier)), required(this.visitNode(node.parameterName), node.parameterName), this.visitNode(node.type));
                 break;
-            case 187 /* SyntaxKind.TypeQuery */:
+            case 188 /* SyntaxKind.TypeQuery */:
                 if (node instanceof TypeQueryNode)
                     return this.factory.updateTypeQueryNode(node, required(this.visitNode(node.exprName), node.exprName), this.visitNodes(node.typeArguments));
                 break;
-            case 184 /* SyntaxKind.TypeReference */:
+            case 185 /* SyntaxKind.TypeReference */:
                 if (node instanceof TypeReferenceNode)
                     return this.factory.updateTypeReferenceNode(node, required(this.visitNode(node.typeName), node.typeName), this.visitNodes(node.typeArguments));
                 break;
-            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.UnionType */:
                 if (node instanceof UnionTypeNode)
                     return this.factory.updateUnionTypeNode(node, this.visitNodes(node.types));
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 if (node instanceof VariableDeclaration)
                     return this.factory.updateVariableDeclaration(node, required(this.visitNode(node.name), node.name), asOptionalToken(this.visitNode(node.exclamationToken)), this.visitNode(node.type), this.visitNode(node.initializer));
                 break;
-            case 262 /* SyntaxKind.VariableDeclarationList */:
+            case 263 /* SyntaxKind.VariableDeclarationList */:
                 if (node instanceof VariableDeclarationList)
                     return this.factory.updateVariableDeclarationList(node, this.visitNodes(node.declarations), node.flags);
                 break;
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 if (node instanceof VariableStatement)
                     return this.factory.updateVariableStatement(node, this.visitModifiers(node.modifiers), asVariableDeclarationList(this.visitNode(node.declarationList), node.declarationList));
                 break;
-            case 223 /* SyntaxKind.VoidExpression */:
+            case 224 /* SyntaxKind.VoidExpression */:
                 if (node instanceof VoidExpression)
                     return this.factory.updateVoidExpression(node, required(this.visitNode(node.expression), node.expression));
                 break;
-            case 248 /* SyntaxKind.WhileStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
                 if (node instanceof WhileStatement)
                     return this.factory.updateWhileStatement(node, required(this.visitNode(node.expression), node.expression), required(this.visitIterationBody(node.statement), node.statement));
                 break;
-            case 255 /* SyntaxKind.WithStatement */:
+            case 256 /* SyntaxKind.WithStatement */:
                 if (node instanceof WithStatement)
                     return this.factory.updateWithStatement(node, required(this.visitNode(node.expression), node.expression), required(this.visitEmbeddedStatement(node.statement), node.statement));
                 break;
-            case 230 /* SyntaxKind.YieldExpression */:
+            case 231 /* SyntaxKind.YieldExpression */:
                 if (node instanceof YieldExpression)
                     return this.factory.updateYieldExpression(node, asOptionalToken(this.visitNode(node.asteriskToken)), this.visitNode(node.expression));
                 break;
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile)
                     return this.factory.updateSourceFile(node, this.visitTopLevelStatements(node.statements), asToken(this.visitToken(node.endOfFileToken), node.endOfFileToken));
                 break;