create-yoya-ui 0.2.0 → 0.2.2

package/templates/admin/node_modules/typescript/dist/ast/visitor.generated.js

@@ -0,0 +1,978 @@
+// 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(node, _tagName, _comment);
+    },
+    [SyntaxKind.JSDocDeprecatedTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocDeprecatedTag(node, _tagName, _comment);
+    },
+    [SyntaxKind.JSDocSeeTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _nameExpression = visitNode(node.nameExpression, visitor, isTypeNode);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocSeeTag(node, _tagName, _nameExpression, _comment);
+    },
+    [SyntaxKind.JSDocImplementsTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _className = visitNode(node.className, visitor, isExpressionWithTypeArguments);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocImplementsTag(node, _tagName, _className, _comment);
+    },
+    [SyntaxKind.JSDocAugmentsTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _className = visitNode(node.className, visitor, isExpressionWithTypeArguments);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocAugmentsTag(node, _tagName, _className, _comment);
+    },
+    [SyntaxKind.JSDocSatisfiesTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _typeExpression = visitNode(node.typeExpression, visitor, isTypeNode);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocSatisfiesTag(node, _tagName, _typeExpression, _comment);
+    },
+    [SyntaxKind.JSDocThrowsTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _typeExpression = visitNode(node.typeExpression, visitor, isTypeNode);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocThrowsTag(node, _tagName, _typeExpression, _comment);
+    },
+    [SyntaxKind.JSDocThisTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _typeExpression = visitNode(node.typeExpression, visitor, isTypeNode);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocThisTag(node, _tagName, _typeExpression, _comment);
+    },
+    [SyntaxKind.JSDocImportTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _importClause = visitNode(node.importClause, visitor, isImportClause);
+        const _moduleSpecifier = visitNode(node.moduleSpecifier, visitor, isExpression);
+        const _attributes = visitNode(node.attributes, visitor, isImportAttributes);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocImportTag(node, _tagName, _importClause, _moduleSpecifier, _attributes, _comment);
+    },
+    [SyntaxKind.JSDocCallbackTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _typeExpression = visitNode(node.typeExpression, visitor, isTypeNode);
+        const _name = visitNode(node.name, visitor, isJSDocFullName);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocCallbackTag(node, _tagName, _typeExpression, _name, _comment);
+    },
+    [SyntaxKind.JSDocOverloadTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _typeExpression = visitNode(node.typeExpression, visitor, isTypeNode);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocOverloadTag(node, _tagName, _typeExpression, _comment);
+    },
+    [SyntaxKind.JSDocTypedefTag]: (node, visitor) => {
+        const _tagName = visitNode(node.tagName, visitor, isIdentifier);
+        const _typeExpression = visitNode(node.typeExpression, visitor);
+        const _name = visitNode(node.name, visitor, isJSDocFullName);
+        const _comment = visitNodes(node.comment, visitor);
+        return updateJSDocTypedefTag(node, _tagName, _typeExpression, _name, _comment);
+    },
+    [SyntaxKind.JSDocSignature]: (node, visitor) => {
+        const _typeParameters = visitNodes(node.typeParameters, visitor);
+        const _parameters = visitNodes(node.parameters, visitor);
+        const _type = visitNode(node.type, visitor, isTypeNode);
+        return updateJSDocSignature(node, _typeParameters, _parameters, _type);
+    },
+    [SyntaxKind.JSDocNameReference]: (node, visitor) => {
+        const _name = visitNode(node.name, visitor, isEntityName);
+        return updateJSDocNameReference(node, _name);
+    },
+    [SyntaxKind.SourceFile]: (node, visitor) => {
+        const _statements = visitNodes(node.statements, visitor);
+        const _endOfFileToken = visitNode(node.endOfFileToken, visitor, isEndOfFile);
+        return updateSourceFile(node, _statements, _endOfFileToken);
+    },
+    [SyntaxKind.ModuleDeclaration]: (node, visitor) => {
+        const _modifiers = visitNodes(node.modifiers, visitor);
+        const _name = visitNode(node.name, visitor, isModuleName);
+        const _body = visitNode(node.body, visitor, isModuleBody);
+        return updateModuleDeclaration(node, _modifiers, _name, _body);
+    },
+    [SyntaxKind.ImportEqualsDeclaration]: (node, visitor) => {
+        const _modifiers = visitNodes(node.modifiers, visitor);
+        const _name = visitNode(node.name, visitor, isIdentifier);
+        const _moduleReference = visitNode(node.moduleReference, visitor, isModuleReference);
+        return updateImportEqualsDeclaration(node, _modifiers, _name, _moduleReference);
+    },
+    [SyntaxKind.ExportDeclaration]: (node, visitor) => {
+        const _modifiers = visitNodes(node.modifiers, visitor);
+        const _exportClause = visitNode(node.exportClause, visitor, isNamedExportBindings);
+        const _moduleSpecifier = visitNode(node.moduleSpecifier, visitor, isExpression);
+        const _attributes = visitNode(node.attributes, visitor, isImportAttributes);
+        return updateExportDeclaration(node, _modifiers, _exportClause, _moduleSpecifier, _attributes);
+    },
+    [SyntaxKind.ImportType]: (node, visitor) => {
+        const _argument = visitNode(node.argument, visitor, isTypeNode);
+        const _attributes = visitNode(node.attributes, visitor, isImportAttributes);
+        const _qualifier = visitNode(node.qualifier, visitor, isEntityName);
+        const _typeArguments = visitNodes(node.typeArguments, visitor);
+        return updateImportTypeNode(node, _argument, _attributes, _qualifier, _typeArguments);
+    },
+    [SyntaxKind.ImportClause]: (node, visitor) => {
+        const _name = visitNode(node.name, visitor, isIdentifier);
+        const _namedBindings = visitNode(node.namedBindings, visitor, isNamedImportBindings);
+        return updateImportClause(node, _name, _namedBindings);
+    },
+    [SyntaxKind.ImportSpecifier]: (node, visitor) => {
+        const _propertyName = visitNode(node.propertyName, visitor, isModuleExportName);
+        const _name = visitNode(node.name, visitor, isIdentifier);
+        return updateImportSpecifier(node, _propertyName, _name);
+    },
+    [SyntaxKind.JSDocLink]: (node, visitor) => {
+        const _name = visitNode(node.name, visitor, isEntityName);
+        return updateJSDocLink(node, _name);
+    },
+    [SyntaxKind.JSDocLinkPlain]: (node, visitor) => {
+        const _name = visitNode(node.name, visitor, isEntityName);
+        return updateJSDocLinkPlain(node, _name);
+    },
+    [SyntaxKind.JSDocLinkCode]: (node, visitor) => {
+        const _name = visitNode(node.name, visitor, isEntityName);
+        return updateJSDocLinkCode(node, _name);
+    },
+    [SyntaxKind.TypeParameter]: (node, visitor) => {
+        const _modifiers = visitNodes(node.modifiers, visitor);
+        const _name = visitNode(node.name, visitor, isIdentifier);
+        const _constraint = visitNode(node.constraint, visitor, isTypeNode);
+        const _expression = visitNode(node.expression, visitor, isExpression);
+        const _defaultType = visitNode(node.defaultType, visitor, isTypeNode);
+        return updateTypeParameterDeclaration(node, _modifiers, _name, _constraint, _expression, _defaultType);
+    },
+    [SyntaxKind.SyntheticReferenceExpression]: (node, visitor) => {
+        const _expression = visitNode(node.expression, visitor, isExpression);
+        const _thisArg = visitNode(node.thisArg, visitor, isExpression);
+        return updateSyntheticReferenceExpression(node, _expression, _thisArg);
+    },
+    [SyntaxKind.JSDocTypeLiteral]: (node, visitor) => {
+        const _jsdocPropertyTags = visitNodesArray(node.jsdocPropertyTags, visitor);
+        return updateJSDocTypeLiteral(node, _jsdocPropertyTags);
+    },
+    [SyntaxKind.ForInStatement]: (node, visitor) => {
+        const _awaitModifier = visitNode(node.awaitModifier, visitor, isAwaitKeyword);
+        const _initializer = visitNode(node.initializer, visitor, isForInitializer);
+        const _expression = visitNode(node.expression, visitor, isExpression);
+        const _statement = visitNode(node.statement, visitor, isStatement);
+        return updateForInStatement(node, _awaitModifier, _initializer, _expression, _statement);
+    },
+    [SyntaxKind.ForOfStatement]: (node, visitor) => {
+        const _awaitModifier = visitNode(node.awaitModifier, visitor, isAwaitKeyword);
+        const _initializer = visitNode(node.initializer, visitor, isForInitializer);
+        const _expression = visitNode(node.expression, visitor, isExpression);
+        const _statement = visitNode(node.statement, visitor, isStatement);
+        return updateForOfStatement(node, _awaitModifier, _initializer, _expression, _statement);
+    },
+    [SyntaxKind.CaseClause]: (node, visitor) => {
+        const _expression = visitNode(node.expression, visitor, isExpression);
+        const _statements = visitNodes(node.statements, visitor);
+        return updateCaseClause(node, _expression, _statements);
+    },
+    [SyntaxKind.DefaultClause]: (node, visitor) => {
+        const _expression = visitNode(node.expression, visitor, isExpression);
+        const _statements = visitNodes(node.statements, visitor);
+        return updateDefaultClause(node, _expression, _statements);
+    },
+    [SyntaxKind.ObjectBindingPattern]: (node, visitor) => {
+        const _elements = visitNodes(node.elements, visitor);
+        return updateObjectBindingPattern(node, _elements);
+    },
+    [SyntaxKind.ArrayBindingPattern]: (node, visitor) => {
+        const _elements = visitNodes(node.elements, visitor);
+        return updateArrayBindingPattern(node, _elements);
+    },
+    [SyntaxKind.JSDocParameterTag]: visitEachChildOfJSDocParameterTag,
+    [SyntaxKind.JSDocPropertyTag]: visitEachChildOfJSDocPropertyTag,
+};
+//# sourceMappingURL=visitor.generated.js.map