typescript/dist/ast/visitor.generated.js

TypeScript is a language for application scale JavaScript development

// Code generated by _scripts/generate-ts-ast.ts. DO NOT EDIT.
import { SyntaxKind } from "#enums/syntaxKind";
import { createNodeArray, updateArrayBindingPattern, updateArrayLiteralExpression, updateArrayTypeNode, updateArrowFunction, updateAsExpression, updateAwaitExpression, updateBinaryExpression, updateBindingElement, updateBlock, updateBreakStatement, updateCallExpression, updateCallSignatureDeclaration, updateCaseBlock, updateCaseClause, updateCatchClause, updateClassDeclaration, updateClassExpression, updateClassStaticBlockDeclaration, updateComputedPropertyName, updateConditionalExpression, updateConditionalTypeNode, updateConstructorDeclaration, updateConstructorTypeNode, updateConstructSignatureDeclaration, updateContinueStatement, updateDecorator, updateDefaultClause, updateDeleteExpression, updateDoStatement, updateElementAccessExpression, updateEnumDeclaration, updateEnumMember, updateExportAssignment, updateExportDeclaration, updateExportSpecifier, updateExpressionStatement, updateExpressionWithTypeArguments, updateExternalModuleReference, updateForInStatement, updateForOfStatement, updateForStatement, updateFunctionDeclaration, updateFunctionExpression, updateFunctionTypeNode, updateGetAccessorDeclaration, updateHeritageClause, updateIfStatement, updateImportAttribute, updateImportAttributes, updateImportClause, updateImportDeclaration, updateImportEqualsDeclaration, updateImportSpecifier, updateImportTypeNode, updateIndexedAccessTypeNode, updateIndexSignatureDeclaration, updateInferTypeNode, updateInterfaceDeclaration, updateIntersectionTypeNode, updateJSDoc, updateJSDocAugmentsTag, updateJSDocCallbackTag, updateJSDocDeprecatedTag, updateJSDocImplementsTag, updateJSDocImportTag, updateJSDocLink, updateJSDocLinkCode, updateJSDocLinkPlain, updateJSDocNameReference, updateJSDocNonNullableType, updateJSDocNullableType, updateJSDocOptionalType, updateJSDocOverloadTag, updateJSDocOverrideTag, updateJSDocPrivateTag, updateJSDocProtectedTag, updateJSDocPublicTag, updateJSDocReadonlyTag, updateJSDocReturnTag, updateJSDocSatisfiesTag, updateJSDocSeeTag, updateJSDocSignature, updateJSDocTemplateTag, updateJSDocThisTag, updateJSDocThrowsTag, updateJSDocTypedefTag, updateJSDocTypeExpression, updateJSDocTypeLiteral, updateJSDocTypeTag, updateJSDocUnknownTag, updateJSDocVariadicType, updateJsxAttribute, updateJsxAttributes, updateJsxClosingElement, updateJsxElement, updateJsxExpression, updateJsxFragment, updateJsxNamespacedName, updateJsxOpeningElement, updateJsxSelfClosingElement, updateJsxSpreadAttribute, updateLabeledStatement, updateLiteralTypeNode, updateMappedTypeNode, updateMetaProperty, updateMethodDeclaration, updateMethodSignatureDeclaration, updateMissingDeclaration, updateModuleBlock, updateModuleDeclaration, updateNamedExports, updateNamedImports, updateNamedTupleMember, updateNamespaceExport, updateNamespaceExportDeclaration, updateNamespaceImport, updateNewExpression, updateNonNullExpression, updateObjectBindingPattern, updateObjectLiteralExpression, updateOptionalTypeNode, updateParameterDeclaration, updateParenthesizedExpression, updateParenthesizedTypeNode, updatePartiallyEmittedExpression, updatePostfixUnaryExpression, updatePrefixUnaryExpression, updatePropertyAccessExpression, updatePropertyAssignment, updatePropertyDeclaration, updatePropertySignatureDeclaration, updateQualifiedName, updateRestTypeNode, updateReturnStatement, updateSatisfiesExpression, updateSetAccessorDeclaration, updateShorthandPropertyAssignment, updateSourceFile, updateSpreadAssignment, updateSpreadElement, updateSwitchStatement, updateSyntaxList, updateSyntheticExpression, updateSyntheticReferenceExpression, updateTaggedTemplateExpression, updateTemplateExpression, updateTemplateLiteralTypeNode, updateTemplateLiteralTypeSpan, updateTemplateSpan, updateThrowStatement, updateTryStatement, updateTupleTypeNode, updateTypeAliasDeclaration, updateTypeAssertion, updateTypeLiteralNode, updateTypeOfExpression, updateTypeOperatorNode, updateTypeParameterDeclaration, updateTypePredicateNode, updateTypeQueryNode, updateTypeReferenceNode, updateUnionTypeNode, updateVariableDeclaration, updateVariableDeclarationList, updateVariableStatement, updateVoidExpression, updateWhileStatement, updateWithStatement, updateYieldExpression, } from "./factory.generated.js";
import { isAssertsKeyword, isAsteriskToken, isAwaitKeyword, isBinaryOperatorToken, isBindingName, isBlock, isCaseBlock, isCatchClause, isColonToken, isConciseBody, isDotDotDotToken, isEndOfFile, isEntityName, isEqualsGreaterThanToken, isEqualsToken, isExclamationToken, isExpression, isExpressionWithTypeArguments, isForInitializer, isFunctionBody, isIdentifier, isImportAttributeName, isImportAttributes, isImportClause, isJSDocFullName, isJsxAttributeName, isJsxAttributes, isJsxAttributeValue, isJsxClosingElement, isJsxClosingFragment, isJsxOpeningElement, isJsxOpeningFragment, isJsxTagNameExpression, isLeftHandSideExpression, isMemberName, isModuleBody, isModuleExportName, isModuleName, isModuleReference, isNamedExportBindings, isNamedImportBindings, isPropertyName, isQuestionDotToken, isQuestionOrExclamationToken, isQuestionOrPlusOrMinusToken, isQuestionToken, isReadonlyKeywordOrPlusOrMinusToken, isStatement, isTemplateHead, isTemplateLiteral, isTemplateMiddleOrTail, isTypeNode, isTypeParameterDeclaration, isTypePredicateParameterName, isVariableDeclaration, isVariableDeclarationList, } from "./is.js";
import { visitEachChildOfJSDocParameterTag, visitEachChildOfJSDocPropertyTag, } from "./visitor.js";
export function visitNode(node, visitor, test) {
    if (node === undefined)
        return undefined;
    const visited = visitor(node);
    if (visited !== undefined && test !== undefined && !test(visited)) {
        throw new Error("Visited node failed test assertion.");
    }
    return visited;
}
export function visitNodes(nodes, visitor) {
    if (nodes === undefined)
        return undefined;
    const updated = visitNodesArray(nodes, visitor);
    if (updated === nodes) {
        return nodes;
    }
    return createNodeArray(updated, nodes.pos, nodes.end);
}
export function visitNodesArray(nodes, visitor) {
    if (nodes === undefined)
        return undefined;
    let updated;
    for (let i = 0; i < nodes.length; i++) {
        const node = nodes[i];
        const visited = visitor(node);
        if (updated) {
            if (visited)
                updated.push(visited);
        }
        else if (visited !== node) {
            updated = [];
            for (let j = 0; j < i; j++)
                updated.push(nodes[j]);
            if (visited)
                updated.push(visited);
        }
    }
    return updated ?? nodes;
}
export function visitEachChild(node, visitor) {
    if (node === undefined)
        return undefined;
    const fn = visitEachChildTable[node.kind];
    return fn ? fn(node, visitor) : node;
}
const visitEachChildTable = {
    [SyntaxKind.QualifiedName]: (node, visitor) => {
        const _left = visitNode(node.left, visitor, isEntityName);
        const _right = visitNode(node.right, visitor, isIdentifier);
        return updateQualifiedName(node, _left, _right);
    },
    [SyntaxKind.ComputedPropertyName]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateComputedPropertyName(node, _expression);
    },
    [SyntaxKind.Decorator]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isLeftHandSideExpression);
        return updateDecorator(node, _expression);
    },
    [SyntaxKind.IfStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _thenStatement = visitNode(node.thenStatement, visitor, isStatement);
        const _elseStatement = visitNode(node.elseStatement, visitor, isStatement);
        return updateIfStatement(node, _expression, _thenStatement, _elseStatement);
    },
    [SyntaxKind.DoStatement]: (node, visitor) => {
        const _statement = visitNode(node.statement, visitor, isStatement);
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateDoStatement(node, _statement, _expression);
    },
    [SyntaxKind.WhileStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _statement = visitNode(node.statement, visitor, isStatement);
        return updateWhileStatement(node, _expression, _statement);
    },
    [SyntaxKind.ForStatement]: (node, visitor) => {
        const _initializer = visitNode(node.initializer, visitor, isForInitializer);
        const _condition = visitNode(node.condition, visitor, isExpression);
        const _incrementor = visitNode(node.incrementor, visitor, isExpression);
        const _statement = visitNode(node.statement, visitor, isStatement);
        return updateForStatement(node, _initializer, _condition, _incrementor, _statement);
    },
    [SyntaxKind.BreakStatement]: (node, visitor) => {
        const _label = visitNode(node.label, visitor, isIdentifier);
        return updateBreakStatement(node, _label);
    },
    [SyntaxKind.ContinueStatement]: (node, visitor) => {
        const _label = visitNode(node.label, visitor, isIdentifier);
        return updateContinueStatement(node, _label);
    },
    [SyntaxKind.ReturnStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateReturnStatement(node, _expression);
    },
    [SyntaxKind.WithStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _statement = visitNode(node.statement, visitor, isStatement);
        return updateWithStatement(node, _expression, _statement);
    },
    [SyntaxKind.SwitchStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _caseBlock = visitNode(node.caseBlock, visitor, isCaseBlock);
        return updateSwitchStatement(node, _expression, _caseBlock);
    },
    [SyntaxKind.CaseBlock]: (node, visitor) => {
        const _clauses = visitNodes(node.clauses, visitor);
        return updateCaseBlock(node, _clauses);
    },
    [SyntaxKind.ThrowStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateThrowStatement(node, _expression);
    },
    [SyntaxKind.TryStatement]: (node, visitor) => {
        const _tryBlock = visitNode(node.tryBlock, visitor, isBlock);
        const _catchClause = visitNode(node.catchClause, visitor, isCatchClause);
        const _finallyBlock = visitNode(node.finallyBlock, visitor, isBlock);
        return updateTryStatement(node, _tryBlock, _catchClause, _finallyBlock);
    },
    [SyntaxKind.CatchClause]: (node, visitor) => {
        const _variableDeclaration = visitNode(node.variableDeclaration, visitor, isVariableDeclaration);
        const _block = visitNode(node.block, visitor, isBlock);
        return updateCatchClause(node, _variableDeclaration, _block);
    },
    [SyntaxKind.LabeledStatement]: (node, visitor) => {
        const _label = visitNode(node.label, visitor, isIdentifier);
        const _statement = visitNode(node.statement, visitor, isStatement);
        return updateLabeledStatement(node, _label, _statement);
    },
    [SyntaxKind.ExpressionStatement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateExpressionStatement(node, _expression);
    },
    [SyntaxKind.Block]: (node, visitor) => {
        const _statements = visitNodes(node.statements, visitor);
        return updateBlock(node, _statements);
    },
    [SyntaxKind.VariableStatement]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _declarationList = visitNode(node.declarationList, visitor, isVariableDeclarationList);
        return updateVariableStatement(node, _modifiers, _declarationList);
    },
    [SyntaxKind.VariableDeclaration]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isBindingName);
        const _exclamationToken = visitNode(node.exclamationToken, visitor, isExclamationToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updateVariableDeclaration(node, _name, _exclamationToken, _type, _initializer);
    },
    [SyntaxKind.VariableDeclarationList]: (node, visitor) => {
        const _declarations = visitNodes(node.declarations, visitor);
        return updateVariableDeclarationList(node, _declarations);
    },
    [SyntaxKind.Parameter]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _dotDotDotToken = visitNode(node.dotDotDotToken, visitor, isDotDotDotToken);
        const _name = visitNode(node.name, visitor, isBindingName);
        const _questionToken = visitNode(node.questionToken, visitor, isQuestionToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updateParameterDeclaration(node, _modifiers, _dotDotDotToken, _name, _questionToken, _type, _initializer);
    },
    [SyntaxKind.BindingElement]: (node, visitor) => {
        const _dotDotDotToken = visitNode(node.dotDotDotToken, visitor, isDotDotDotToken);
        const _propertyName = visitNode(node.propertyName, visitor, isPropertyName);
        const _name = visitNode(node.name, visitor, isBindingName);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updateBindingElement(node, _dotDotDotToken, _propertyName, _name, _initializer);
    },
    [SyntaxKind.MissingDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        return updateMissingDeclaration(node, _modifiers);
    },
    [SyntaxKind.FunctionDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _asteriskToken = visitNode(node.asteriskToken, visitor, isAsteriskToken);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _body = visitNode(node.body, visitor, isFunctionBody);
        return updateFunctionDeclaration(node, _modifiers, _asteriskToken, _name, _typeParameters, _parameters, _type, _body);
    },
    [SyntaxKind.ClassDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _heritageClauses = visitNodes(node.heritageClauses, visitor);
        const _members = visitNodes(node.members, visitor);
        return updateClassDeclaration(node, _modifiers, _name, _typeParameters, _heritageClauses, _members);
    },
    [SyntaxKind.ClassExpression]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _heritageClauses = visitNodes(node.heritageClauses, visitor);
        const _members = visitNodes(node.members, visitor);
        return updateClassExpression(node, _modifiers, _name, _typeParameters, _heritageClauses, _members);
    },
    [SyntaxKind.HeritageClause]: (node, visitor) => {
        const _types = visitNodes(node.types, visitor);
        return updateHeritageClause(node, _types);
    },
    [SyntaxKind.InterfaceDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _heritageClauses = visitNodes(node.heritageClauses, visitor);
        const _members = visitNodes(node.members, visitor);
        return updateInterfaceDeclaration(node, _modifiers, _name, _typeParameters, _heritageClauses, _members);
    },
    [SyntaxKind.TypeAliasDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateTypeAliasDeclaration(node, _modifiers, _name, _typeParameters, _type);
    },
    [SyntaxKind.EnumMember]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updateEnumMember(node, _name, _initializer);
    },
    [SyntaxKind.EnumDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _members = visitNodes(node.members, visitor);
        return updateEnumDeclaration(node, _modifiers, _name, _members);
    },
    [SyntaxKind.ModuleBlock]: (node, visitor) => {
        const _statements = visitNodes(node.statements, visitor);
        return updateModuleBlock(node, _statements);
    },
    [SyntaxKind.ImportDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _importClause = visitNode(node.importClause, visitor, isImportClause);
        const _moduleSpecifier = visitNode(node.moduleSpecifier, visitor, isExpression);
        const _attributes = visitNode(node.attributes, visitor, isImportAttributes);
        return updateImportDeclaration(node, _modifiers, _importClause, _moduleSpecifier, _attributes);
    },
    [SyntaxKind.ExternalModuleReference]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateExternalModuleReference(node, _expression);
    },
    [SyntaxKind.NamespaceImport]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isIdentifier);
        return updateNamespaceImport(node, _name);
    },
    [SyntaxKind.NamedImports]: (node, visitor) => {
        const _elements = visitNodes(node.elements, visitor);
        return updateNamedImports(node, _elements);
    },
    [SyntaxKind.ExportAssignment]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateExportAssignment(node, _modifiers, _type, _expression);
    },
    [SyntaxKind.NamespaceExportDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isIdentifier);
        return updateNamespaceExportDeclaration(node, _modifiers, _name);
    },
    [SyntaxKind.NamespaceExport]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isModuleExportName);
        return updateNamespaceExport(node, _name);
    },
    [SyntaxKind.NamedExports]: (node, visitor) => {
        const _elements = visitNodes(node.elements, visitor);
        return updateNamedExports(node, _elements);
    },
    [SyntaxKind.ExportSpecifier]: (node, visitor) => {
        const _propertyName = visitNode(node.propertyName, visitor, isModuleExportName);
        const _name = visitNode(node.name, visitor, isModuleExportName);
        return updateExportSpecifier(node, _propertyName, _name);
    },
    [SyntaxKind.CallSignature]: (node, visitor) => {
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateCallSignatureDeclaration(node, _typeParameters, _parameters, _type);
    },
    [SyntaxKind.ConstructSignature]: (node, visitor) => {
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateConstructSignatureDeclaration(node, _typeParameters, _parameters, _type);
    },
    [SyntaxKind.Constructor]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _body = visitNode(node.body, visitor, isFunctionBody);
        return updateConstructorDeclaration(node, _modifiers, _typeParameters, _parameters, _type, _body);
    },
    [SyntaxKind.GetAccessor]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _body = visitNode(node.body, visitor, isFunctionBody);
        return updateGetAccessorDeclaration(node, _modifiers, _name, _typeParameters, _parameters, _type, _body);
    },
    [SyntaxKind.SetAccessor]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _body = visitNode(node.body, visitor, isFunctionBody);
        return updateSetAccessorDeclaration(node, _modifiers, _name, _typeParameters, _parameters, _type, _body);
    },
    [SyntaxKind.IndexSignature]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateIndexSignatureDeclaration(node, _modifiers, _parameters, _type);
    },
    [SyntaxKind.MethodSignature]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _postfixToken = visitNode(node.postfixToken, visitor, isQuestionOrExclamationToken);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateMethodSignatureDeclaration(node, _modifiers, _name, _postfixToken, _typeParameters, _parameters, _type);
    },
    [SyntaxKind.MethodDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _asteriskToken = visitNode(node.asteriskToken, visitor, isAsteriskToken);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _postfixToken = visitNode(node.postfixToken, visitor, isQuestionOrExclamationToken);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _body = visitNode(node.body, visitor, isFunctionBody);
        return updateMethodDeclaration(node, _modifiers, _asteriskToken, _name, _postfixToken, _typeParameters, _parameters, _type, _body);
    },
    [SyntaxKind.PropertySignature]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _postfixToken = visitNode(node.postfixToken, visitor, isQuestionOrExclamationToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updatePropertySignatureDeclaration(node, _modifiers, _name, _postfixToken, _type, _initializer);
    },
    [SyntaxKind.PropertyDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _postfixToken = visitNode(node.postfixToken, visitor, isQuestionOrExclamationToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updatePropertyDeclaration(node, _modifiers, _name, _postfixToken, _type, _initializer);
    },
    [SyntaxKind.ClassStaticBlockDeclaration]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _body = visitNode(node.body, visitor, isBlock);
        return updateClassStaticBlockDeclaration(node, _modifiers, _body);
    },
    [SyntaxKind.BinaryExpression]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _left = visitNode(node.left, visitor, isExpression);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _operatorToken = visitNode(node.operatorToken, visitor, isBinaryOperatorToken);
        const _right = visitNode(node.right, visitor, isExpression);
        return updateBinaryExpression(node, _modifiers, _left, _type, _operatorToken, _right);
    },
    [SyntaxKind.PrefixUnaryExpression]: (node, visitor) => {
        const _operand = visitNode(node.operand, visitor, isExpression);
        return updatePrefixUnaryExpression(node, _operand);
    },
    [SyntaxKind.PostfixUnaryExpression]: (node, visitor) => {
        const _operand = visitNode(node.operand, visitor, isExpression);
        return updatePostfixUnaryExpression(node, _operand);
    },
    [SyntaxKind.YieldExpression]: (node, visitor) => {
        const _asteriskToken = visitNode(node.asteriskToken, visitor, isAsteriskToken);
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateYieldExpression(node, _asteriskToken, _expression);
    },
    [SyntaxKind.ArrowFunction]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _equalsGreaterThanToken = visitNode(node.equalsGreaterThanToken, visitor, isEqualsGreaterThanToken);
        const _body = visitNode(node.body, visitor, isConciseBody);
        return updateArrowFunction(node, _modifiers, _typeParameters, _parameters, _type, _equalsGreaterThanToken, _body);
    },
    [SyntaxKind.FunctionExpression]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _asteriskToken = visitNode(node.asteriskToken, visitor, isAsteriskToken);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _body = visitNode(node.body, visitor, isFunctionBody);
        return updateFunctionExpression(node, _modifiers, _asteriskToken, _name, _typeParameters, _parameters, _type, _body);
    },
    [SyntaxKind.AsExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateAsExpression(node, _expression, _type);
    },
    [SyntaxKind.SatisfiesExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateSatisfiesExpression(node, _expression, _type);
    },
    [SyntaxKind.ConditionalExpression]: (node, visitor) => {
        const _condition = visitNode(node.condition, visitor, isExpression);
        const _questionToken = visitNode(node.questionToken, visitor, isQuestionToken);
        const _whenTrue = visitNode(node.whenTrue, visitor, isExpression);
        const _colonToken = visitNode(node.colonToken, visitor, isColonToken);
        const _whenFalse = visitNode(node.whenFalse, visitor, isExpression);
        return updateConditionalExpression(node, _condition, _questionToken, _whenTrue, _colonToken, _whenFalse);
    },
    [SyntaxKind.PropertyAccessExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _questionDotToken = visitNode(node.questionDotToken, visitor, isQuestionDotToken);
        const _name = visitNode(node.name, visitor, isMemberName);
        return updatePropertyAccessExpression(node, _expression, _questionDotToken, _name);
    },
    [SyntaxKind.ElementAccessExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _questionDotToken = visitNode(node.questionDotToken, visitor, isQuestionDotToken);
        const _argumentExpression = visitNode(node.argumentExpression, visitor, isExpression);
        return updateElementAccessExpression(node, _expression, _questionDotToken, _argumentExpression);
    },
    [SyntaxKind.CallExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _questionDotToken = visitNode(node.questionDotToken, visitor, isQuestionDotToken);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        const _arguments = visitNodes(node.arguments, visitor);
        return updateCallExpression(node, _expression, _questionDotToken, _typeArguments, _arguments);
    },
    [SyntaxKind.NewExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        const _arguments = visitNodes(node.arguments, visitor);
        return updateNewExpression(node, _expression, _typeArguments, _arguments);
    },
    [SyntaxKind.MetaProperty]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isIdentifier);
        return updateMetaProperty(node, _name);
    },
    [SyntaxKind.NonNullExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateNonNullExpression(node, _expression);
    },
    [SyntaxKind.SpreadElement]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateSpreadElement(node, _expression);
    },
    [SyntaxKind.TemplateExpression]: (node, visitor) => {
        const _head = visitNode(node.head, visitor, isTemplateHead);
        const _templateSpans = visitNodes(node.templateSpans, visitor);
        return updateTemplateExpression(node, _head, _templateSpans);
    },
    [SyntaxKind.TemplateSpan]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _literal = visitNode(node.literal, visitor, isTemplateMiddleOrTail);
        return updateTemplateSpan(node, _expression, _literal);
    },
    [SyntaxKind.TaggedTemplateExpression]: (node, visitor) => {
        const _tag = visitNode(node.tag, visitor, isExpression);
        const _questionDotToken = visitNode(node.questionDotToken, visitor, isQuestionDotToken);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        const _template = visitNode(node.template, visitor, isTemplateLiteral);
        return updateTaggedTemplateExpression(node, _tag, _questionDotToken, _typeArguments, _template);
    },
    [SyntaxKind.ParenthesizedExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateParenthesizedExpression(node, _expression);
    },
    [SyntaxKind.ArrayLiteralExpression]: (node, visitor) => {
        const _elements = visitNodes(node.elements, visitor);
        return updateArrayLiteralExpression(node, _elements);
    },
    [SyntaxKind.ObjectLiteralExpression]: (node, visitor) => {
        const _properties = visitNodes(node.properties, visitor);
        return updateObjectLiteralExpression(node, _properties);
    },
    [SyntaxKind.SpreadAssignment]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateSpreadAssignment(node, _expression);
    },
    [SyntaxKind.PropertyAssignment]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _postfixToken = visitNode(node.postfixToken, visitor, isQuestionOrExclamationToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _initializer = visitNode(node.initializer, visitor, isExpression);
        return updatePropertyAssignment(node, _modifiers, _name, _postfixToken, _type, _initializer);
    },
    [SyntaxKind.ShorthandPropertyAssignment]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _name = visitNode(node.name, visitor, isPropertyName);
        const _postfixToken = visitNode(node.postfixToken, visitor, isQuestionOrExclamationToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _equalsToken = visitNode(node.equalsToken, visitor, isEqualsToken);
        const _objectAssignmentInitializer = visitNode(node.objectAssignmentInitializer, visitor, isExpression);
        return updateShorthandPropertyAssignment(node, _modifiers, _name, _postfixToken, _type, _equalsToken, _objectAssignmentInitializer);
    },
    [SyntaxKind.DeleteExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateDeleteExpression(node, _expression);
    },
    [SyntaxKind.TypeOfExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateTypeOfExpression(node, _expression);
    },
    [SyntaxKind.VoidExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateVoidExpression(node, _expression);
    },
    [SyntaxKind.AwaitExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateAwaitExpression(node, _expression);
    },
    [SyntaxKind.TypeAssertionExpression]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateTypeAssertion(node, _type, _expression);
    },
    [SyntaxKind.UnionType]: (node, visitor) => {
        const _types = visitNodes(node.types, visitor);
        return updateUnionTypeNode(node, _types);
    },
    [SyntaxKind.IntersectionType]: (node, visitor) => {
        const _types = visitNodes(node.types, visitor);
        return updateIntersectionTypeNode(node, _types);
    },
    [SyntaxKind.ConditionalType]: (node, visitor) => {
        const _checkType = visitNode(node.checkType, visitor, isTypeNode);
        const _extendsType = visitNode(node.extendsType, visitor, isTypeNode);
        const _trueType = visitNode(node.trueType, visitor, isTypeNode);
        const _falseType = visitNode(node.falseType, visitor, isTypeNode);
        return updateConditionalTypeNode(node, _checkType, _extendsType, _trueType, _falseType);
    },
    [SyntaxKind.TypeOperator]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateTypeOperatorNode(node, _type);
    },
    [SyntaxKind.InferType]: (node, visitor) => {
        const _typeParameter = visitNode(node.typeParameter, visitor, isTypeParameterDeclaration);
        return updateInferTypeNode(node, _typeParameter);
    },
    [SyntaxKind.ArrayType]: (node, visitor) => {
        const _elementType = visitNode(node.elementType, visitor, isTypeNode);
        return updateArrayTypeNode(node, _elementType);
    },
    [SyntaxKind.IndexedAccessType]: (node, visitor) => {
        const _objectType = visitNode(node.objectType, visitor, isTypeNode);
        const _indexType = visitNode(node.indexType, visitor, isTypeNode);
        return updateIndexedAccessTypeNode(node, _objectType, _indexType);
    },
    [SyntaxKind.TypeReference]: (node, visitor) => {
        const _typeName = visitNode(node.typeName, visitor, isEntityName);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        return updateTypeReferenceNode(node, _typeName, _typeArguments);
    },
    [SyntaxKind.ExpressionWithTypeArguments]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        return updateExpressionWithTypeArguments(node, _expression, _typeArguments);
    },
    [SyntaxKind.LiteralType]: (node, visitor) => {
        const _literal = visitNode(node.literal, visitor);
        return updateLiteralTypeNode(node, _literal);
    },
    [SyntaxKind.TypePredicate]: (node, visitor) => {
        const _assertsModifier = visitNode(node.assertsModifier, visitor, isAssertsKeyword);
        const _parameterName = visitNode(node.parameterName, visitor, isTypePredicateParameterName);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateTypePredicateNode(node, _assertsModifier, _parameterName, _type);
    },
    [SyntaxKind.ImportAttribute]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isImportAttributeName);
        const _value = visitNode(node.value, visitor, isExpression);
        return updateImportAttribute(node, _name, _value);
    },
    [SyntaxKind.ImportAttributes]: (node, visitor) => {
        const _attributes = visitNodes(node.attributes, visitor);
        return updateImportAttributes(node, _attributes);
    },
    [SyntaxKind.TypeQuery]: (node, visitor) => {
        const _exprName = visitNode(node.exprName, visitor, isEntityName);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        return updateTypeQueryNode(node, _exprName, _typeArguments);
    },
    [SyntaxKind.MappedType]: (node, visitor) => {
        const _readonlyToken = visitNode(node.readonlyToken, visitor, isReadonlyKeywordOrPlusOrMinusToken);
        const _typeParameter = visitNode(node.typeParameter, visitor, isTypeParameterDeclaration);
        const _nameType = visitNode(node.nameType, visitor, isTypeNode);
        const _questionToken = visitNode(node.questionToken, visitor, isQuestionOrPlusOrMinusToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _members = visitNodes(node.members, visitor);
        return updateMappedTypeNode(node, _readonlyToken, _typeParameter, _nameType, _questionToken, _type, _members);
    },
    [SyntaxKind.TypeLiteral]: (node, visitor) => {
        const _members = visitNodes(node.members, visitor);
        return updateTypeLiteralNode(node, _members);
    },
    [SyntaxKind.TupleType]: (node, visitor) => {
        const _elements = visitNodes(node.elements, visitor);
        return updateTupleTypeNode(node, _elements);
    },
    [SyntaxKind.NamedTupleMember]: (node, visitor) => {
        const _dotDotDotToken = visitNode(node.dotDotDotToken, visitor, isDotDotDotToken);
        const _name = visitNode(node.name, visitor, isIdentifier);
        const _questionToken = visitNode(node.questionToken, visitor, isQuestionToken);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateNamedTupleMember(node, _dotDotDotToken, _name, _questionToken, _type);
    },
    [SyntaxKind.OptionalType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateOptionalTypeNode(node, _type);
    },
    [SyntaxKind.RestType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateRestTypeNode(node, _type);
    },
    [SyntaxKind.ParenthesizedType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateParenthesizedTypeNode(node, _type);
    },
    [SyntaxKind.FunctionType]: (node, visitor) => {
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateFunctionTypeNode(node, _typeParameters, _parameters, _type);
    },
    [SyntaxKind.ConstructorType]: (node, visitor) => {
        const _modifiers = visitNodes(node.modifiers, visitor);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _parameters = visitNodes(node.parameters, visitor);
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateConstructorTypeNode(node, _modifiers, _typeParameters, _parameters, _type);
    },
    [SyntaxKind.TemplateLiteralType]: (node, visitor) => {
        const _head = visitNode(node.head, visitor, isTemplateHead);
        const _templateSpans = visitNodes(node.templateSpans, visitor);
        return updateTemplateLiteralTypeNode(node, _head, _templateSpans);
    },
    [SyntaxKind.TemplateLiteralTypeSpan]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        const _literal = visitNode(node.literal, visitor, isTemplateMiddleOrTail);
        return updateTemplateLiteralTypeSpan(node, _type, _literal);
    },
    [SyntaxKind.SyntheticExpression]: (node, visitor) => {
        const _tupleNameSource = visitNode(node.tupleNameSource, visitor);
        return updateSyntheticExpression(node, _tupleNameSource);
    },
    [SyntaxKind.PartiallyEmittedExpression]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updatePartiallyEmittedExpression(node, _expression);
    },
    [SyntaxKind.JsxElement]: (node, visitor) => {
        const _openingElement = visitNode(node.openingElement, visitor, isJsxOpeningElement);
        const _children = visitNodes(node.children, visitor);
        const _closingElement = visitNode(node.closingElement, visitor, isJsxClosingElement);
        return updateJsxElement(node, _openingElement, _children, _closingElement);
    },
    [SyntaxKind.JsxAttributes]: (node, visitor) => {
        const _properties = visitNodes(node.properties, visitor);
        return updateJsxAttributes(node, _properties);
    },
    [SyntaxKind.JsxNamespacedName]: (node, visitor) => {
        const _namespace = visitNode(node.namespace, visitor, isIdentifier);
        const _name = visitNode(node.name, visitor, isIdentifier);
        return updateJsxNamespacedName(node, _namespace, _name);
    },
    [SyntaxKind.JsxOpeningElement]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isJsxTagNameExpression);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        const _attributes = visitNode(node.attributes, visitor, isJsxAttributes);
        return updateJsxOpeningElement(node, _tagName, _typeArguments, _attributes);
    },
    [SyntaxKind.JsxSelfClosingElement]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isJsxTagNameExpression);
        const _typeArguments = visitNodes(node.typeArguments, visitor);
        const _attributes = visitNode(node.attributes, visitor, isJsxAttributes);
        return updateJsxSelfClosingElement(node, _tagName, _typeArguments, _attributes);
    },
    [SyntaxKind.JsxFragment]: (node, visitor) => {
        const _openingFragment = visitNode(node.openingFragment, visitor, isJsxOpeningFragment);
        const _children = visitNodes(node.children, visitor);
        const _closingFragment = visitNode(node.closingFragment, visitor, isJsxClosingFragment);
        return updateJsxFragment(node, _openingFragment, _children, _closingFragment);
    },
    [SyntaxKind.JsxAttribute]: (node, visitor) => {
        const _name = visitNode(node.name, visitor, isJsxAttributeName);
        const _initializer = visitNode(node.initializer, visitor, isJsxAttributeValue);
        return updateJsxAttribute(node, _name, _initializer);
    },
    [SyntaxKind.JsxSpreadAttribute]: (node, visitor) => {
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateJsxSpreadAttribute(node, _expression);
    },
    [SyntaxKind.JsxClosingElement]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isJsxTagNameExpression);
        return updateJsxClosingElement(node, _tagName);
    },
    [SyntaxKind.JsxExpression]: (node, visitor) => {
        const _dotDotDotToken = visitNode(node.dotDotDotToken, visitor, isDotDotDotToken);
        const _expression = visitNode(node.expression, visitor, isExpression);
        return updateJsxExpression(node, _dotDotDotToken, _expression);
    },
    [SyntaxKind.SyntaxList]: (node, visitor) => {
        const _children = visitNodesArray(node.children, visitor);
        return updateSyntaxList(node, _children);
    },
    [SyntaxKind.JSDoc]: (node, visitor) => {
        const _comment = visitNodes(node.comment, visitor);
        const _tags = visitNodes(node.tags, visitor);
        return updateJSDoc(node, _comment, _tags);
    },
    [SyntaxKind.JSDocTypeExpression]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateJSDocTypeExpression(node, _type);
    },
    [SyntaxKind.JSDocNonNullableType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateJSDocNonNullableType(node, _type);
    },
    [SyntaxKind.JSDocNullableType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateJSDocNullableType(node, _type);
    },
    [SyntaxKind.JSDocVariadicType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateJSDocVariadicType(node, _type);
    },
    [SyntaxKind.JSDocOptionalType]: (node, visitor) => {
        const _type = visitNode(node.type, visitor, isTypeNode);
        return updateJSDocOptionalType(node, _type);
    },
    [SyntaxKind.JSDocTypeTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _typeExpression = visitNode(node.typeExpression, visitor);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocTypeTag(node, _tagName, _typeExpression, _comment);
    },
    [SyntaxKind.JSDocUnknownTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocUnknownTag(node, _tagName, _comment);
    },
    [SyntaxKind.JSDocTemplateTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _constraint = visitNode(node.constraint, visitor);
        const _typeParameters = visitNodes(node.typeParameters, visitor);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocTemplateTag(node, _tagName, _constraint, _typeParameters, _comment);
    },
    [SyntaxKind.JSDocReturnTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _typeExpression = visitNode(node.typeExpression, visitor, isTypeNode);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocReturnTag(node, _tagName, _typeExpression, _comment);
    },
    [SyntaxKind.JSDocPublicTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocPublicTag(node, _tagName, _comment);
    },
    [SyntaxKind.JSDocPrivateTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocPrivateTag(node, _tagName, _comment);
    },
    [SyntaxKind.JSDocProtectedTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocProtectedTag(node, _tagName, _comment);
    },
    [SyntaxKind.JSDocReadonlyTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocReadonlyTag(node, _tagName, _comment);
    },
    [SyntaxKind.JSDocOverrideTag]: (node, visitor) => {
        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
        const _comment = visitNodes(node.comment, visitor);
        return updateJSDocOverrideTag(no