import {

__String,

AccessorDeclaration,

addRange,

append,

appendIfUnique,

ArrayBindingElement,

ArrayBindingPattern,

ArrayLiteralExpression,

ArrayTypeNode,

ArrowFunction,

AsExpression,

AssertClause,

AssertEntry,

AssertionKey,

AssertsKeyword,

AssignmentPattern,

AsteriskToken,

AwaitExpression,

AwaitKeyword,

BaseNodeFactory,

BigIntLiteral,

BinaryExpression,

BinaryOperator,

BinaryOperatorToken,

BindingElement,

BindingName,

BindingPattern,

Block,

BooleanLiteral,

BreakStatement,

Bundle,

CallBinding,

CallChain,

CallExpression,

CallSignatureDeclaration,

CaseBlock,

CaseClause,

CaseOrDefaultClause,

cast,

CatchClause,

CharacterCodes,

ClassDeclaration,

ClassElement,

ClassExpression,

ClassStaticBlockDeclaration,

ColonToken,

CommaListExpression,

ComputedPropertyName,

ConciseBody,

ConditionalExpression,

ConditionalTypeNode,

ConstructorDeclaration,

ConstructorTypeNode,

ConstructSignatureDeclaration,

containsObjectRestOrSpread,

ContinueStatement,

createBaseNodeFactory,

createNodeConverters,

createParenthesizerRules,

createScanner,

Debug,

DebuggerStatement,

Declaration,

DeclarationName,

Decorator,

DefaultClause,

DeleteExpression,

DoStatement,

DotDotDotToken,

ElementAccessChain,

ElementAccessExpression,

EmitFlags,

EmitNode,

emptyArray,

EmptyStatement,

EndOfFileToken,

EntityName,

EnumDeclaration,

EnumMember,

EqualsGreaterThanToken,

escapeLeadingUnderscores,

every,

ExclamationToken,

ExportAssignment,

ExportDeclaration,

ExportSpecifier,

Expression,

ExpressionStatement,

ExpressionWithTypeArguments,

ExternalModuleReference,

FalseLiteral,

FileReference,

findUseStrictPrologue,

forEach,

ForInitializer,

ForInStatement,

formatGeneratedName,

ForOfStatement,

ForStatement,

FunctionDeclaration,

FunctionExpression,

FunctionTypeNode,

GeneratedIdentifier,

GeneratedIdentifierFlags,

GeneratedNamePart,

GeneratedPrivateIdentifier,

GetAccessorDeclaration,

getCommentRange,

getEmitFlags,

getIdentifierTypeArguments,

getJSDocTypeAliasName,

getNameOfDeclaration,

getNodeId,

getNonAssignedNameOfDeclaration,

getSourceMapRange,

getSyntheticLeadingComments,

getSyntheticTrailingComments,

getTextOfIdentifierOrLiteral,

HasDecorators,

hasInvalidEscape,

HasModifiers,

hasProperty,

hasSyntacticModifier,

HeritageClause,

Identifier,

identity,

idText,

IfStatement,

ImmediatelyInvokedArrowFunction,

ImmediatelyInvokedFunctionExpression,

ImportAttribute,

ImportAttributeName,

ImportAttributes,

ImportClause,

ImportDeclaration,

ImportEqualsDeclaration,

ImportSpecifier,

ImportTypeAssertionContainer,

ImportTypeNode,

IndexedAccessTypeNode,

IndexSignatureDeclaration,

InferTypeNode,

InterfaceDeclaration,

InternalEmitFlags,

IntersectionTypeNode,

isArray,

isArrayLiteralExpression,

isArrowFunction,

isBinaryExpression,

isCallChain,

isClassDeclaration,

isClassExpression,

isCommaListExpression,

isCommaToken,

isComputedPropertyName,

isConstructorDeclaration,

isConstructorTypeNode,

isCustomPrologue,

isElementAccessChain,

isElementAccessExpression,

isEnumDeclaration,

isExclamationToken,

isExportAssignment,

isExportDeclaration,

isExternalModuleReference,

isFunctionDeclaration,

isFunctionExpression,

isGeneratedIdentifier,

isGeneratedPrivateIdentifier,

isGetAccessorDeclaration,

isHoistedFunction,

isHoistedVariableStatement,

isIdentifier,

isImportDeclaration,

isImportEqualsDeclaration,

isImportKeyword,

isIndexSignatureDeclaration,

isInterfaceDeclaration,

isLabeledStatement,

isLocalName,

isLogicalOrCoalescingAssignmentOperator,

isMemberName,

isMethodDeclaration,

isMethodSignature,

isModuleDeclaration,

isNamedDeclaration,

isNodeArray,

isNodeKind,

isNonNullChain,

isNotEmittedStatement,

isObjectLiteralExpression,

isOmittedExpression,

isOuterExpression,

isParameter,

isParenthesizedExpression,

isParseTreeNode,

isPrivateIdentifier,

isPrologueDirective,

isPropertyAccessChain,

isPropertyAccessExpression,

isPropertyDeclaration,

isPropertyName,

isPropertySignature,

isQuestionToken,

isSetAccessorDeclaration,

isSourceFile,

isStatement,

isStatementOrBlock,

isStringLiteral,

isSuperKeyword,

isSuperProperty,

isThisIdentifier,

isTypeAliasDeclaration,

isTypeParameterDeclaration,

isVariableDeclaration,

isVariableStatement,

JSDoc,

JSDocAllType,

JSDocAugmentsTag,

JSDocAuthorTag,

JSDocCallbackTag,

JSDocClassTag,

JSDocComment,

JSDocDeprecatedTag,

JSDocEnumTag,

JSDocFunctionType,

JSDocImplementsTag,

JSDocImportTag,

JSDocLink,

JSDocLinkCode,

JSDocLinkPlain,

JSDocMemberName,

JSDocNamepathType,

JSDocNameReference,

JSDocNamespaceDeclaration,

JSDocNonNullableType,

JSDocNullableType,

JSDocOptionalType,

JSDocOverloadTag,

JSDocOverrideTag,

JSDocParameterTag,

JSDocPrivateTag,

JSDocPropertyLikeTag,

JSDocPropertyTag,

JSDocProtectedTag,

JSDocPublicTag,

JSDocReadonlyTag,

JSDocReturnTag,

JSDocSatisfiesTag,

JSDocSeeTag,

JSDocSignature,

JSDocTag,

JSDocTemplateTag,

JSDocText,

JSDocThisTag,

JSDocThrowsTag,

JSDocType,

JSDocTypedefTag,

JSDocTypeExpression,

JSDocTypeLiteral,

JSDocTypeTag,

JSDocUnknownTag,

JSDocUnknownType,

JSDocVariadicType,

JsxAttribute,

JsxAttributeLike,

JsxAttributeName,

JsxAttributes,

JsxAttributeValue,

JsxChild,

JsxClosingElement,

JsxClosingFragment,

JsxElement,

JsxExpression,

JsxFragment,

JsxNamespacedName,

JsxOpeningElement,

JsxOpeningFragment,

JsxSelfClosingElement,

JsxSpreadAttribute,

JsxTagNameExpression,

JsxText,

KeywordSyntaxKind,

KeywordToken,

KeywordTypeNode,

KeywordTypeSyntaxKind,

LabeledStatement,

LanguageVariant,

lastOrUndefined,

LeftHandSideExpression,

LiteralToken,

LiteralTypeNode,

MappedTypeNode,

MemberName,

memoize,

memoizeOne,

MetaProperty,

MethodDeclaration,

MethodSignature,

MinusToken,

MissingDeclaration,

Modifier,

ModifierFlags,

ModifierLike,

modifiersToFlags,

ModifierSyntaxKind,

ModifierToken,

ModuleBlock,

ModuleBody,

ModuleDeclaration,

ModuleName,

ModuleReference,

Mutable,

MutableNodeArray,

NamedExportBindings,

NamedExports,

NamedImportBindings,

NamedImports,

NamedTupleMember,

NamespaceExport,

NamespaceExportDeclaration,

NamespaceImport,

NewExpression,

Node,

NodeArray,

NodeFactory,

NodeFlags,

nodeIsSynthesized,

NonNullChain,

NonNullExpression,

NoSubstitutionTemplateLiteral,

NotEmittedStatement,

NullLiteral,

nullNodeConverters,

nullParenthesizerRules,

NumericLiteral,

objectAllocator,

ObjectBindingPattern,

ObjectLiteralElementLike,

ObjectLiteralExpression,

OmittedExpression,

OptionalTypeNode,

OuterExpression,

OuterExpressionKinds,

ParameterDeclaration,

ParenthesizedExpression,

ParenthesizedTypeNode,

PartiallyEmittedExpression,

Path,

PlusToken,

PostfixUnaryExpression,

PostfixUnaryOperator,

PrefixUnaryExpression,

PrefixUnaryOperator,

PrimaryExpression,

PrivateIdentifier,

PrologueDirective,

PropertyAccessChain,

PropertyAccessExpression,

PropertyAssignment,

PropertyDeclaration,

PropertyDescriptorAttributes,

PropertyName,

PropertyNameLiteral,

PropertySignature,

PseudoBigInt,

pseudoBigIntToString,

PunctuationSyntaxKind,

PunctuationToken,

QualifiedName,

QuestionDotToken,

QuestionToken,

ReadonlyKeyword,

RedirectInfo,

reduceLeft,

RegularExpressionLiteral,

RestTypeNode,

ReturnStatement,

returnTrue,

sameFlatMap,

SatisfiesExpression,

Scanner,

ScriptTarget,

SemicolonClassElement,

SetAccessorDeclaration,

setEmitFlags,

setIdentifierAutoGenerate,

setIdentifierTypeArguments,

setNodeChildren,

setParent,

setTextRange,

ShorthandPropertyAssignment,

SignatureDeclarationBase,

singleOrUndefined,

skipOuterExpressions,

skipParentheses,

some,

SourceFile,

SourceMapSource,

SpreadAssignment,

SpreadElement,

startOnNewLine,

startsWith,

Statement,

StringLiteral,

stringToToken,

SuperExpression,

SwitchStatement,

SyntaxKind,

SyntaxList,

SyntheticExpression,

SyntheticReferenceExpression,

TaggedTemplateExpression,

TemplateExpression,

TemplateHead,

TemplateLiteral,

TemplateLiteralLikeNode,

TemplateLiteralToken,

TemplateLiteralTypeNode,

TemplateLiteralTypeSpan,

TemplateMiddle,

TemplateSpan,

TemplateTail,

TextRange,

ThisExpression,

ThisTypeNode,

ThrowStatement,

Token,

TokenFlags,

TransformFlags,

TrueLiteral,

TryStatement,

TupleTypeNode,

Type,

TypeAliasDeclaration,

TypeAssertion,

TypeElement,

TypeLiteralNode,

TypeNode,

TypeOfExpression,

TypeOfTag,

TypeOperatorNode,

TypeParameterDeclaration,

TypePredicateNode,

TypeQueryNode,

TypeReferenceNode,

UnionOrIntersectionTypeNode,

UnionTypeNode,

VariableDeclaration,

VariableDeclarationList,

VariableStatement,

visitNode,

VisitResult,

VoidExpression,

WhileStatement,

WithStatement,

YieldExpression,

} from "../_namespaces/ts.js";

let nextAutoGenerateId = 0;

/** @internal */

export const enum NodeFactoryFlags {

None = 0,

// Disables the parenthesizer rules for the factory.

NoParenthesizerRules = 1 << 0,

// Disables the node converters for the factory.

NoNodeConverters = 1 << 1,

// Ensures new `PropertyAccessExpression` nodes are created with the `NoIndentation` emit flag set.

NoIndentationOnFreshPropertyAccess = 1 << 2,

// Do not set an `original` pointer when updating a node.

NoOriginalNode = 1 << 3,

}

const nodeFactoryPatchers: ((factory: NodeFactory) => void)[] = [];

/** @internal */

export function addNodeFactoryPatcher(fn: (factory: NodeFactory) => void) {

nodeFactoryPatchers.push(fn);

}

/**

* Creates a `NodeFactory` that can be used to create and update a syntax tree.

* @param flags Flags that control factory behavior.

* @param baseFactory A `BaseNodeFactory` used to create the base `Node` objects.

*

* @internal

*/

export function createNodeFactory(flags: NodeFactoryFlags, baseFactory: BaseNodeFactory): NodeFactory {

const setOriginal = flags & NodeFactoryFlags.NoOriginalNode ? identity : setOriginalNode;

// Lazily load the parenthesizer, node converters, and some factory methods until they are used.

const parenthesizerRules = memoize(() => flags & NodeFactoryFlags.NoParenthesizerRules ? nullParenthesizerRules : createParenthesizerRules(factory));

const converters = memoize(() => flags & NodeFactoryFlags.NoNodeConverters ? nullNodeConverters : createNodeConverters(factory));

// lazy initializaton of common operator factories

const getBinaryCreateFunction = memoizeOne((operator: BinaryOperator) => (left: Expression, right: Expression) => createBinaryExpression(left, operator, right));

const getPrefixUnaryCreateFunction = memoizeOne((operator: PrefixUnaryOperator) => (operand: Expression) => createPrefixUnaryExpression(operator, operand));

const getPostfixUnaryCreateFunction = memoizeOne((operator: PostfixUnaryOperator) => (operand: Expression) => createPostfixUnaryExpression(operand, operator));

const getJSDocPrimaryTypeCreateFunction = memoizeOne(<T extends JSDocType>(kind: T["kind"]) => () => createJSDocPrimaryTypeWorker(kind));

const getJSDocUnaryTypeCreateFunction = memoizeOne(<T extends JSDocType & { readonly type: TypeNode | undefined; }>(kind: T["kind"]) => (type: T["type"]) => createJSDocUnaryTypeWorker<T>(kind, type));

const getJSDocUnaryTypeUpdateFunction = memoizeOne(<T extends JSDocType & { readonly type: TypeNode | undefined; }>(kind: T["kind"]) => (node: T, type: T["type"]) => updateJSDocUnaryTypeWorker<T>(kind, node, type));

const getJSDocPrePostfixUnaryTypeCreateFunction = memoizeOne(<T extends JSDocType & { readonly type: TypeNode | undefined; readonly postfix: boolean; }>(kind: T["kind"]) => (type: T["type"], postfix?: boolean) => createJSDocPrePostfixUnaryTypeWorker<T>(kind, type, postfix));

const getJSDocPrePostfixUnaryTypeUpdateFunction = memoizeOne(<T extends JSDocType & { readonly type: TypeNode | undefined; readonly postfix: boolean; }>(kind: T["kind"]) => (node: T, type: T["type"]) => updateJSDocPrePostfixUnaryTypeWorker<T>(kind, node, type));

const getJSDocSimpleTagCreateFunction = memoizeOne(<T extends JSDocTag>(kind: T["kind"]) => (tagName: Identifier | undefined, comment?: NodeArray<JSDocComment>) => createJSDocSimpleTagWorker(kind, tagName, comment));

const getJSDocSimpleTagUpdateFunction = memoizeOne(<T extends JSDocTag>(kind: T["kind"]) => (node: T, tagName: Identifier | undefined, comment?: NodeArray<JSDocComment>) => updateJSDocSimpleTagWorker(kind, node, tagName, comment));

const getJSDocTypeLikeTagCreateFunction = memoizeOne(<T extends JSDocTag & { typeExpression?: JSDocTypeExpression; }>(kind: T["kind"]) => (tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: NodeArray<JSDocComment>) => createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment));

const getJSDocTypeLikeTagUpdateFunction = memoizeOne(<T extends JSDocTag & { typeExpression?: JSDocTypeExpression; }>(kind: T["kind"]) => (node: T, tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: NodeArray<JSDocComment>) => updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment));

const factory: NodeFactory = {

get parenthesizer() {

return parenthesizerRules();

},

get converters() {

return converters();

},

baseFactory,

flags,

createNodeArray,

createNumericLiteral,

createBigIntLiteral,

createStringLiteral,

createStringLiteralFromNode,

createRegularExpressionLiteral,

createLiteralLikeNode,

createIdentifier,

createTempVariable,

createLoopVariable,

createUniqueName,

getGeneratedNameForNode,

createPrivateIdentifier,

createUniquePrivateName,

getGeneratedPrivateNameForNode,

createToken,

createSuper,

createThis,

createNull,

createTrue,

createFalse,

createModifier,

createModifiersFromModifierFlags,

createQualifiedName,

updateQualifiedName,

createComputedPropertyName,

updateComputedPropertyName,

createTypeParameterDeclaration,

updateTypeParameterDeclaration,

createParameterDeclaration,

updateParameterDeclaration,

createDecorator,

updateDecorator,

createPropertySignature,

updatePropertySignature,

createPropertyDeclaration,

updatePropertyDeclaration,

createMethodSignature,

updateMethodSignature,

createMethodDeclaration,

updateMethodDeclaration,

createConstructorDeclaration,

updateConstructorDeclaration,

createGetAccessorDeclaration,

updateGetAccessorDeclaration,

createSetAccessorDeclaration,

updateSetAccessorDeclaration,

createCallSignature,

updateCallSignature,

createConstructSignature,

updateConstructSignature,

createIndexSignature,

updateIndexSignature,

createClassStaticBlockDeclaration,

updateClassStaticBlockDeclaration,

createTemplateLiteralTypeSpan,

updateTemplateLiteralTypeSpan,

createKeywordTypeNode,

createTypePredicateNode,

updateTypePredicateNode,

createTypeReferenceNode,

updateTypeReferenceNode,

createFunctionTypeNode,

updateFunctionTypeNode,

createConstructorTypeNode,

updateConstructorTypeNode,

createTypeQueryNode,

updateTypeQueryNode,

createTypeLiteralNode,

updateTypeLiteralNode,

createArrayTypeNode,

updateArrayTypeNode,

createTupleTypeNode,

updateTupleTypeNode,

createNamedTupleMember,

updateNamedTupleMember,

createOptionalTypeNode,

updateOptionalTypeNode,

createRestTypeNode,

updateRestTypeNode,

createUnionTypeNode,

updateUnionTypeNode,

createIntersectionTypeNode,

updateIntersectionTypeNode,

createConditionalTypeNode,

updateConditionalTypeNode,

createInferTypeNode,

updateInferTypeNode,

createImportTypeNode,

updateImportTypeNode,

createParenthesizedType,

updateParenthesizedType,

createThisTypeNode,

createTypeOperatorNode,

updateTypeOperatorNode,

createIndexedAccessTypeNode,

updateIndexedAccessTypeNode,

createMappedTypeNode,

updateMappedTypeNode,

createLiteralTypeNode,

updateLiteralTypeNode,

createTemplateLiteralType,

updateTemplateLiteralType,

createObjectBindingPattern,

updateObjectBindingPattern,

createArrayBindingPattern,

updateArrayBindingPattern,

createBindingElement,

updateBindingElement,

createArrayLiteralExpression,

updateArrayLiteralExpression,

createObjectLiteralExpression,

updateObjectLiteralExpression,

createPropertyAccessExpression: flags & NodeFactoryFlags.NoIndentationOnFreshPropertyAccess ?

(expression, name) => setEmitFlags(createPropertyAccessExpression(expression, name), EmitFlags.NoIndentation) :

createPropertyAccessExpression,

updatePropertyAccessExpression,

createPropertyAccessChain: flags & NodeFactoryFlags.NoIndentationOnFreshPropertyAccess ?

(expression, questionDotToken, name: string) => setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), EmitFlags.NoIndentation) :

createPropertyAccessChain,

updatePropertyAccessChain,

createElementAccessExpression,

updateElementAccessExpression,

createElementAccessChain,

updateElementAccessChain,

createCallExpression,

updateCallExpression,

createCallChain,

updateCallChain,

createNewExpression,

updateNewExpression,

createTaggedTemplateExpression,

updateTaggedTemplateExpression,

createTypeAssertion,

updateTypeAssertion,

createParenthesizedExpression,

updateParenthesizedExpression,

createFunctionExpression,

updateFunctionExpression,

createArrowFunction,

updateArrowFunction,

createDeleteExpression,

updateDeleteExpression,

createTypeOfExpression,

updateTypeOfExpression,

createVoidExpression,

updateVoidExpression,

createAwaitExpression,

updateAwaitExpression,

createPrefixUnaryExpression,

updatePrefixUnaryExpression,

createPostfixUnaryExpression,

updatePostfixUnaryExpression,

createBinaryExpression,

updateBinaryExpression,

createConditionalExpression,

updateConditionalExpression,

createTemplateExpression,

updateTemplateExpression,

createTemplateHead,

createTemplateMiddle,

createTemplateTail,

createNoSubstitutionTemplateLiteral,

createTemplateLiteralLikeNode,

createYieldExpression,

updateYieldExpression,

createSpreadElement,

updateSpreadElement,

createClassExpression,

updateClassExpression,

createOmittedExpression,

createExpressionWithTypeArguments,

updateExpressionWithTypeArguments,

createAsExpression,

updateAsExpression,

createNonNullExpression,

updateNonNullExpression,

createSatisfiesExpression,

updateSatisfiesExpression,

createNonNullChain,

updateNonNullChain,

createMetaProperty,

updateMetaProperty,

createTemplateSpan,

updateTemplateSpan,

createSemicolonClassElement,

createBlock,

updateBlock,

createVariableStatement,

updateVariableStatement,

createEmptyStatement,

createExpressionStatement,

updateExpressionStatement,

createIfStatement,

updateIfStatement,

createDoStatement,

updateDoStatement,

createWhileStatement,

updateWhileStatement,

createForStatement,

updateForStatement,

createForInStatement,

updateForInStatement,

createForOfStatement,

updateForOfStatement,

createContinueStatement,

updateContinueStatement,

createBreakStatement,

updateBreakStatement,

createReturnStatement,

updateReturnStatement,

createWithStatement,

updateWithStatement,

createSwitchStatement,

updateSwitchStatement,

createLabeledStatement,

updateLabeledStatement,

createThrowStatement,

updateThrowStatement,

createTryStatement,

updateTryStatement,

createDebuggerStatement,

createVariableDeclaration,

updateVariableDeclaration,

createVariableDeclarationList,

updateVariableDeclarationList,

createFunctionDeclaration,

updateFunctionDeclaration,

createClassDeclaration,

updateClassDeclaration,

createInterfaceDeclaration,

updateInterfaceDeclaration,

createTypeAliasDeclaration,

updateTypeAliasDeclaration,

createEnumDeclaration,

updateEnumDeclaration,

createModuleDeclaration,

updateModuleDeclaration,

createModuleBlock,

updateModuleBlock,

createCaseBlock,

updateCaseBlock,

createNamespaceExportDeclaration,

updateNamespaceExportDeclaration,

createImportEqualsDeclaration,

updateImportEqualsDeclaration,

createImportDeclaration,

updateImportDeclaration,

createImportClause,

updateImportClause,

createAssertClause,

updateAssertClause,

createAssertEntry,

updateAssertEntry,

createImportTypeAssertionContainer,

updateImportTypeAssertionContainer,

createImportAttributes,

updateImportAttributes,

createImportAttribute,

updateImportAttribute,

createNamespaceImport,

updateNamespaceImport,

createNamespaceExport,

updateNamespaceExport,

createNamedImports,

updateNamedImports,

createImportSpecifier,

updateImportSpecifier,

createExportAssignment,

updateExportAssignment,

createExportDeclaration,

updateExportDeclaration,

createNamedExports,

updateNamedExports,

createExportSpecifier,

updateExportSpecifier,

createMissingDeclaration,

createExternalModuleReference,

updateExternalModuleReference,

// lazily load factory members for JSDoc types with similar structure

get createJSDocAllType() {

return getJSDocPrimaryTypeCreateFunction<JSDocAllType>(SyntaxKind.JSDocAllType);

},

get createJSDocUnknownType() {

return getJSDocPrimaryTypeCreateFunction<JSDocUnknownType>(SyntaxKind.JSDocUnknownType);

},

get createJSDocNonNullableType() {

return getJSDocPrePostfixUnaryTypeCreateFunction<JSDocNonNullableType>(SyntaxKind.JSDocNonNullableType);

},

get updateJSDocNonNullableType() {

return getJSDocPrePostfixUnaryTypeUpdateFunction<JSDocNonNullableType>(SyntaxKind.JSDocNonNullableType);

},

get createJSDocNullableType() {

return getJSDocPrePostfixUnaryTypeCreateFunction<JSDocNullableType>(SyntaxKind.JSDocNullableType);

},

get updateJSDocNullableType() {

return getJSDocPrePostfixUnaryTypeUpdateFunction<JSDocNullableType>(SyntaxKind.JSDocNullableType);

},

get createJSDocOptionalType() {

return getJSDocUnaryTypeCreateFunction<JSDocOptionalType>(SyntaxKind.JSDocOptionalType);

},

get updateJSDocOptionalType() {

return getJSDocUnaryTypeUpdateFunction<JSDocOptionalType>(SyntaxKind.JSDocOptionalType);

},

get createJSDocVariadicType() {

return getJSDocUnaryTypeCreateFunction<JSDocVariadicType>(SyntaxKind.JSDocVariadicType);

},

get updateJSDocVariadicType() {

return getJSDocUnaryTypeUpdateFunction<JSDocVariadicType>(SyntaxKind.JSDocVariadicType);

},

get createJSDocNamepathType() {

return getJSDocUnaryTypeCreateFunction<JSDocNamepathType>(SyntaxKind.JSDocNamepathType);

},

get updateJSDocNamepathType() {

return getJSDocUnaryTypeUpdateFunction<JSDocNamepathType>(SyntaxKind.JSDocNamepathType);

},

createJSDocFunctionType,

updateJSDocFunctionType,

createJSDocTypeLiteral,

updateJSDocTypeLiteral,

createJSDocTypeExpression,

updateJSDocTypeExpression,

createJSDocSignature,

updateJSDocSignature,

createJSDocTemplateTag,

updateJSDocTemplateTag,

createJSDocTypedefTag,

updateJSDocTypedefTag,

createJSDocParameterTag,

updateJSDocParameterTag,

createJSDocPropertyTag,

updateJSDocPropertyTag,

createJSDocCallbackTag,

updateJSDocCallbackTag,

createJSDocOverloadTag,

updateJSDocOverloadTag,

createJSDocAugmentsTag,

updateJSDocAugmentsTag,

createJSDocImplementsTag,

updateJSDocImplementsTag,

createJSDocSeeTag,

updateJSDocSeeTag,

createJSDocImportTag,

updateJSDocImportTag,

createJSDocNameReference,

updateJSDocNameReference,

createJSDocMemberName,

updateJSDocMemberName,

createJSDocLink,

updateJSDocLink,

createJSDocLinkCode,

updateJSDocLinkCode,

createJSDocLinkPlain,

updateJSDocLinkPlain,

// lazily load factory members for JSDoc tags with similar structure

get createJSDocTypeTag() {

return getJSDocTypeLikeTagCreateFunction<JSDocTypeTag>(SyntaxKind.JSDocTypeTag);

},

get updateJSDocTypeTag() {

return getJSDocTypeLikeTagUpdateFunction<JSDocTypeTag>(SyntaxKind.JSDocTypeTag);

},

get createJSDocReturnTag() {

return getJSDocTypeLikeTagCreateFunction<JSDocReturnTag>(SyntaxKind.JSDocReturnTag);

},

get updateJSDocReturnTag() {

return getJSDocTypeLikeTagUpdateFunction<JSDocReturnTag>(SyntaxKind.JSDocReturnTag);

},

get createJSDocThisTag() {

return getJSDocTypeLikeTagCreateFunction<JSDocThisTag>(SyntaxKind.JSDocThisTag);

},

get updateJSDocThisTag() {

return getJSDocTypeLikeTagUpdateFunction<JSDocThisTag>(SyntaxKind.JSDocThisTag);

},

get createJSDocAuthorTag() {

return getJSDocSimpleTagCreateFunction<JSDocAuthorTag>(SyntaxKind.JSDocAuthorTag);

},

get updateJSDocAuthorTag() {

return getJSDocSimpleTagUpdateFunction<JSDocAuthorTag>(SyntaxKind.JSDocAuthorTag);

},

get createJSDocClassTag() {

return getJSDocSimpleTagCreateFunction<JSDocClassTag>(SyntaxKind.JSDocClassTag);

},

get updateJSDocClassTag() {

return getJSDocSimpleTagUpdateFunction<JSDocClassTag>(SyntaxKind.JSDocClassTag);

},

get createJSDocPublicTag() {

return getJSDocSimpleTagCreateFunction<JSDocPublicTag>(SyntaxKind.JSDocPublicTag);

},

get updateJSDocPublicTag() {

return getJSDocSimpleTagUpdateFunction<JSDocPublicTag>(SyntaxKind.JSDocPublicTag);

},

get createJSDocPrivateTag() {

return getJSDocSimpleTagCreateFunction<JSDocPrivateTag>(SyntaxKind.JSDocPrivateTag);

},

get updateJSDocPrivateTag() {

return getJSDocSimpleTagUpdateFunction<JSDocPrivateTag>(SyntaxKind.JSDocPrivateTag);

},

get createJSDocProtectedTag() {

return getJSDocSimpleTagCreateFunction<JSDocProtectedTag>(SyntaxKind.JSDocProtectedTag);

},

get updateJSDocProtectedTag() {

return getJSDocSimpleTagUpdateFunction<JSDocProtectedTag>(SyntaxKind.JSDocProtectedTag);

},

get createJSDocReadonlyTag() {

return getJSDocSimpleTagCreateFunction<JSDocReadonlyTag>(SyntaxKind.JSDocReadonlyTag);

},

get updateJSDocReadonlyTag() {

return getJSDocSimpleTagUpdateFunction<JSDocReadonlyTag>(SyntaxKind.JSDocReadonlyTag);

},

get createJSDocOverrideTag() {

return getJSDocSimpleTagCreateFunction<JSDocOverrideTag>(SyntaxKind.JSDocOverrideTag);

},

get updateJSDocOverrideTag() {

return getJSDocSimpleTagUpdateFunction<JSDocOverrideTag>(SyntaxKind.JSDocOverrideTag);

},

get createJSDocDeprecatedTag() {

return getJSDocSimpleTagCreateFunction<JSDocDeprecatedTag>(SyntaxKind.JSDocDeprecatedTag);

},

get updateJSDocDeprecatedTag() {

return getJSDocSimpleTagUpdateFunction<JSDocDeprecatedTag>(SyntaxKind.JSDocDeprecatedTag);

},

get createJSDocThrowsTag() {

return getJSDocTypeLikeTagCreateFunction<JSDocThrowsTag>(SyntaxKind.JSDocThrowsTag);

},

get updateJSDocThrowsTag() {

return getJSDocTypeLikeTagUpdateFunction<JSDocThrowsTag>(SyntaxKind.JSDocThrowsTag);

},

get createJSDocSatisfiesTag() {

return getJSDocTypeLikeTagCreateFunction<JSDocSatisfiesTag>(SyntaxKind.JSDocSatisfiesTag);

},

get updateJSDocSatisfiesTag() {

return getJSDocTypeLikeTagUpdateFunction<JSDocSatisfiesTag>(SyntaxKind.JSDocSatisfiesTag);

},

createJSDocEnumTag,

updateJSDocEnumTag,

createJSDocUnknownTag,

updateJSDocUnknownTag,

createJSDocText,

updateJSDocText,

createJSDocComment,

updateJSDocComment,

createJsxElement,

updateJsxElement,

createJsxSelfClosingElement,

updateJsxSelfClosingElement,

createJsxOpeningElement,

updateJsxOpeningElement,

createJsxClosingElement,

updateJsxClosingElement,

createJsxFragment,

createJsxText,

updateJsxText,

createJsxOpeningFragment,

createJsxJsxClosingFragment,

updateJsxFragment,

createJsxAttribute,

updateJsxAttribute,

createJsxAttributes,

updateJsxAttributes,

createJsxSpreadAttribute,

updateJsxSpreadAttribute,

createJsxExpression,

updateJsxExpression,

createJsxNamespacedName,

updateJsxNamespacedName,

createCaseClause,

updateCaseClause,

createDefaultClause,

updateDefaultClause,

createHeritageClause,

updateHeritageClause,

createCatchClause,

updateCatchClause,

createPropertyAssignment,

updatePropertyAssignment,

createShorthandPropertyAssignment,

updateShorthandPropertyAssignment,

createSpreadAssignment,

updateSpreadAssignment,

createEnumMember,