namespace ts {

// branded string type used to store absolute, normalized and canonicalized paths

// arbitrary file name can be converted to Path via toPath function

export type Path = string & { __pathBrand: any };

/* @internal */

export type MatchingKeys<TRecord, TMatch, K extends keyof TRecord = keyof TRecord> = K extends (TRecord[K] extends TMatch ? K : never) ? K : never;

export interface TextRange {

pos: number;

end: number;

}

export interface ReadonlyTextRange {

readonly pos: number;

readonly end: number;

}

// token > SyntaxKind.Identifier => token is a keyword

// Also, If you add a new SyntaxKind be sure to keep the `Markers` section at the bottom in sync

export const enum SyntaxKind {

Unknown,

EndOfFileToken,

SingleLineCommentTrivia,

MultiLineCommentTrivia,

NewLineTrivia,

WhitespaceTrivia,

// We detect and preserve #! on the first line

ShebangTrivia,

// We detect and provide better error recovery when we encounter a git merge marker. This

// allows us to edit files with git-conflict markers in them in a much more pleasant manner.

ConflictMarkerTrivia,

// Literals

NumericLiteral,

BigIntLiteral,

StringLiteral,

JsxText,

JsxTextAllWhiteSpaces,

RegularExpressionLiteral,

NoSubstitutionTemplateLiteral,

// Pseudo-literals

TemplateHead,

TemplateMiddle,

TemplateTail,

// Punctuation

OpenBraceToken,

CloseBraceToken,

OpenParenToken,

CloseParenToken,

OpenBracketToken,

CloseBracketToken,

DotToken,

DotDotDotToken,

SemicolonToken,

CommaToken,

QuestionDotToken,

LessThanToken,

LessThanSlashToken,

GreaterThanToken,

LessThanEqualsToken,

GreaterThanEqualsToken,

EqualsEqualsToken,

ExclamationEqualsToken,

EqualsEqualsEqualsToken,

ExclamationEqualsEqualsToken,

EqualsGreaterThanToken,

PlusToken,

MinusToken,

AsteriskToken,

AsteriskAsteriskToken,

SlashToken,

PercentToken,

PlusPlusToken,

MinusMinusToken,

LessThanLessThanToken,

GreaterThanGreaterThanToken,

GreaterThanGreaterThanGreaterThanToken,

AmpersandToken,

BarToken,

CaretToken,

ExclamationToken,

TildeToken,

AmpersandAmpersandToken,

BarBarToken,

QuestionToken,

ColonToken,

AtToken,

QuestionQuestionToken,

/** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */

BacktickToken,

// Assignments

EqualsToken,

PlusEqualsToken,

MinusEqualsToken,

AsteriskEqualsToken,

AsteriskAsteriskEqualsToken,

SlashEqualsToken,

PercentEqualsToken,

LessThanLessThanEqualsToken,

GreaterThanGreaterThanEqualsToken,

GreaterThanGreaterThanGreaterThanEqualsToken,

AmpersandEqualsToken,

BarEqualsToken,

BarBarEqualsToken,

AmpersandAmpersandEqualsToken,

QuestionQuestionEqualsToken,

CaretEqualsToken,

// Identifiers and PrivateIdentifiers

Identifier,

PrivateIdentifier,

// Reserved words

BreakKeyword,

CaseKeyword,

CatchKeyword,

ClassKeyword,

ConstKeyword,

ContinueKeyword,

DebuggerKeyword,

DefaultKeyword,

DeleteKeyword,

DoKeyword,

ElseKeyword,

EnumKeyword,

ExportKeyword,

ExtendsKeyword,

FalseKeyword,

FinallyKeyword,

ForKeyword,

FunctionKeyword,

IfKeyword,

ImportKeyword,

InKeyword,

InstanceOfKeyword,

NewKeyword,

NullKeyword,

ReturnKeyword,

SuperKeyword,

SwitchKeyword,

ThisKeyword,

ThrowKeyword,

TrueKeyword,

TryKeyword,

TypeOfKeyword,

VarKeyword,

VoidKeyword,

WhileKeyword,

WithKeyword,

// Strict mode reserved words

ImplementsKeyword,

InterfaceKeyword,

LetKeyword,

PackageKeyword,

PrivateKeyword,

ProtectedKeyword,

PublicKeyword,

StaticKeyword,

YieldKeyword,

// Contextual keywords

AbstractKeyword,

AsKeyword,

AssertsKeyword,

AnyKeyword,

AsyncKeyword,

AwaitKeyword,

BooleanKeyword,

ConstructorKeyword,

DeclareKeyword,

GetKeyword,

InferKeyword,

IntrinsicKeyword,

IsKeyword,

KeyOfKeyword,

ModuleKeyword,

NamespaceKeyword,

NeverKeyword,

ReadonlyKeyword,

RequireKeyword,

NumberKeyword,

ObjectKeyword,

SetKeyword,

StringKeyword,

SymbolKeyword,

TypeKeyword,

UndefinedKeyword,

UniqueKeyword,

UnknownKeyword,

FromKeyword,

GlobalKeyword,

BigIntKeyword,

OverrideKeyword,

OfKeyword, // LastKeyword and LastToken and LastContextualKeyword

// Parse tree nodes

// Names

QualifiedName,

ComputedPropertyName,

// Signature elements

TypeParameter,

Parameter,

Decorator,

// TypeMember

PropertySignature,

PropertyDeclaration,

MethodSignature,

MethodDeclaration,

Constructor,

GetAccessor,

SetAccessor,

CallSignature,

ConstructSignature,

IndexSignature,

// Type

TypePredicate,

TypeReference,

FunctionType,

ConstructorType,

TypeQuery,

TypeLiteral,

ArrayType,

TupleType,

OptionalType,

RestType,

UnionType,

IntersectionType,

ConditionalType,

InferType,

ParenthesizedType,

ThisType,

TypeOperator,

IndexedAccessType,

MappedType,

LiteralType,

NamedTupleMember,

TemplateLiteralType,

TemplateLiteralTypeSpan,

ImportType,

// Binding patterns

ObjectBindingPattern,

ArrayBindingPattern,

BindingElement,

// Expression

ArrayLiteralExpression,

ObjectLiteralExpression,

PropertyAccessExpression,

ElementAccessExpression,

CallExpression,

NewExpression,

TaggedTemplateExpression,

TypeAssertionExpression,

ParenthesizedExpression,

FunctionExpression,

ArrowFunction,

DeleteExpression,

TypeOfExpression,

VoidExpression,

AwaitExpression,

PrefixUnaryExpression,

PostfixUnaryExpression,

BinaryExpression,

ConditionalExpression,

TemplateExpression,

YieldExpression,

SpreadElement,

ClassExpression,

OmittedExpression,

ExpressionWithTypeArguments,

AsExpression,

NonNullExpression,

MetaProperty,

SyntheticExpression,

// Misc

TemplateSpan,

SemicolonClassElement,

// Element

Block,

EmptyStatement,

VariableStatement,

ExpressionStatement,

IfStatement,

DoStatement,

WhileStatement,

ForStatement,

ForInStatement,

ForOfStatement,

ContinueStatement,

BreakStatement,

ReturnStatement,

WithStatement,

SwitchStatement,

LabeledStatement,

ThrowStatement,

TryStatement,

DebuggerStatement,

VariableDeclaration,

VariableDeclarationList,

FunctionDeclaration,

ClassDeclaration,

InterfaceDeclaration,

TypeAliasDeclaration,

EnumDeclaration,

ModuleDeclaration,

ModuleBlock,

CaseBlock,

NamespaceExportDeclaration,

ImportEqualsDeclaration,

ImportDeclaration,

ImportClause,

NamespaceImport,

NamedImports,

ImportSpecifier,

ExportAssignment,

ExportDeclaration,

NamedExports,

NamespaceExport,

ExportSpecifier,

MissingDeclaration,

// Module references

ExternalModuleReference,

// JSX

JsxElement,

JsxSelfClosingElement,

JsxOpeningElement,

JsxClosingElement,

JsxFragment,

JsxOpeningFragment,

JsxClosingFragment,

JsxAttribute,

JsxAttributes,

JsxSpreadAttribute,

JsxExpression,

// Clauses

CaseClause,

DefaultClause,

HeritageClause,

CatchClause,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

SpreadAssignment,

// Enum

EnumMember,

// Unparsed

UnparsedPrologue,

UnparsedPrepend,

UnparsedText,

UnparsedInternalText,

UnparsedSyntheticReference,

// Top-level nodes

SourceFile,

Bundle,

UnparsedSource,

InputFiles,

// JSDoc nodes

JSDocTypeExpression,

JSDocNameReference,

JSDocAllType, // The * type

JSDocUnknownType, // The ? type

JSDocNullableType,

JSDocNonNullableType,

JSDocOptionalType,

JSDocFunctionType,

JSDocVariadicType,

JSDocNamepathType, // https://jsdoc.app/about-namepaths.html

JSDocComment,

JSDocText,

JSDocTypeLiteral,

JSDocSignature,

JSDocLink,

JSDocTag,

JSDocAugmentsTag,

JSDocImplementsTag,

JSDocAuthorTag,

JSDocDeprecatedTag,

JSDocClassTag,

JSDocPublicTag,

JSDocPrivateTag,

JSDocProtectedTag,

JSDocReadonlyTag,

JSDocOverrideTag,

JSDocCallbackTag,

JSDocEnumTag,

JSDocParameterTag,

JSDocReturnTag,

JSDocThisTag,

JSDocTypeTag,

JSDocTemplateTag,

JSDocTypedefTag,

JSDocSeeTag,

JSDocPropertyTag,

// Synthesized list

SyntaxList,

// Transformation nodes

NotEmittedStatement,

PartiallyEmittedExpression,

CommaListExpression,

MergeDeclarationMarker,

EndOfDeclarationMarker,

SyntheticReferenceExpression,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstCompoundAssignment = PlusEqualsToken,

LastCompoundAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = OfKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword,

FirstTypeNode = TypePredicate,

LastTypeNode = ImportType,

FirstPunctuation = OpenBraceToken,

LastPunctuation = CaretEqualsToken,

FirstToken = Unknown,

LastToken = LastKeyword,

FirstTriviaToken = SingleLineCommentTrivia,

LastTriviaToken = ConflictMarkerTrivia,

FirstLiteralToken = NumericLiteral,

LastLiteralToken = NoSubstitutionTemplateLiteral,

FirstTemplateToken = NoSubstitutionTemplateLiteral,

LastTemplateToken = TemplateTail,

FirstBinaryOperator = LessThanToken,

LastBinaryOperator = CaretEqualsToken,

FirstStatement = VariableStatement,

LastStatement = DebuggerStatement,

FirstNode = QualifiedName,

FirstJSDocNode = JSDocTypeExpression,

LastJSDocNode = JSDocPropertyTag,

FirstJSDocTagNode = JSDocTag,

LastJSDocTagNode = JSDocPropertyTag,

/* @internal */ FirstContextualKeyword = AbstractKeyword,

/* @internal */ LastContextualKeyword = OfKeyword,

}

export type TriviaSyntaxKind =

| SyntaxKind.SingleLineCommentTrivia

| SyntaxKind.MultiLineCommentTrivia

| SyntaxKind.NewLineTrivia

| SyntaxKind.WhitespaceTrivia

| SyntaxKind.ShebangTrivia

| SyntaxKind.ConflictMarkerTrivia

;

export type LiteralSyntaxKind =

| SyntaxKind.NumericLiteral

| SyntaxKind.BigIntLiteral

| SyntaxKind.StringLiteral

| SyntaxKind.JsxText

| SyntaxKind.JsxTextAllWhiteSpaces

| SyntaxKind.RegularExpressionLiteral

| SyntaxKind.NoSubstitutionTemplateLiteral

;

export type PseudoLiteralSyntaxKind =

| SyntaxKind.TemplateHead

| SyntaxKind.TemplateMiddle

| SyntaxKind.TemplateTail

;

export type PunctuationSyntaxKind =

| SyntaxKind.OpenBraceToken

| SyntaxKind.CloseBraceToken

| SyntaxKind.OpenParenToken

| SyntaxKind.CloseParenToken

| SyntaxKind.OpenBracketToken

| SyntaxKind.CloseBracketToken

| SyntaxKind.DotToken

| SyntaxKind.DotDotDotToken

| SyntaxKind.SemicolonToken

| SyntaxKind.CommaToken

| SyntaxKind.QuestionDotToken

| SyntaxKind.LessThanToken

| SyntaxKind.LessThanSlashToken

| SyntaxKind.GreaterThanToken

| SyntaxKind.LessThanEqualsToken

| SyntaxKind.GreaterThanEqualsToken

| SyntaxKind.EqualsEqualsToken

| SyntaxKind.ExclamationEqualsToken

| SyntaxKind.EqualsEqualsEqualsToken

| SyntaxKind.ExclamationEqualsEqualsToken

| SyntaxKind.EqualsGreaterThanToken

| SyntaxKind.PlusToken

| SyntaxKind.MinusToken

| SyntaxKind.AsteriskToken

| SyntaxKind.AsteriskAsteriskToken

| SyntaxKind.SlashToken

| SyntaxKind.PercentToken

| SyntaxKind.PlusPlusToken

| SyntaxKind.MinusMinusToken

| SyntaxKind.LessThanLessThanToken

| SyntaxKind.GreaterThanGreaterThanToken

| SyntaxKind.GreaterThanGreaterThanGreaterThanToken

| SyntaxKind.AmpersandToken

| SyntaxKind.BarToken

| SyntaxKind.CaretToken

| SyntaxKind.ExclamationToken

| SyntaxKind.TildeToken

| SyntaxKind.AmpersandAmpersandToken

| SyntaxKind.BarBarToken

| SyntaxKind.QuestionQuestionToken

| SyntaxKind.QuestionToken

| SyntaxKind.ColonToken

| SyntaxKind.AtToken

| SyntaxKind.BacktickToken

| SyntaxKind.EqualsToken

| SyntaxKind.PlusEqualsToken

| SyntaxKind.MinusEqualsToken

| SyntaxKind.AsteriskEqualsToken

| SyntaxKind.AsteriskAsteriskEqualsToken

| SyntaxKind.SlashEqualsToken

| SyntaxKind.PercentEqualsToken

| SyntaxKind.LessThanLessThanEqualsToken

| SyntaxKind.GreaterThanGreaterThanEqualsToken

| SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken

| SyntaxKind.AmpersandEqualsToken

| SyntaxKind.BarEqualsToken

| SyntaxKind.CaretEqualsToken

;

export type KeywordSyntaxKind =

| SyntaxKind.AbstractKeyword

| SyntaxKind.AnyKeyword

| SyntaxKind.AsKeyword

| SyntaxKind.AssertsKeyword

| SyntaxKind.AsyncKeyword

| SyntaxKind.AwaitKeyword

| SyntaxKind.BigIntKeyword

| SyntaxKind.BooleanKeyword

| SyntaxKind.BreakKeyword

| SyntaxKind.CaseKeyword

| SyntaxKind.CatchKeyword

| SyntaxKind.ClassKeyword

| SyntaxKind.ConstKeyword

| SyntaxKind.ConstructorKeyword

| SyntaxKind.ContinueKeyword

| SyntaxKind.DebuggerKeyword

| SyntaxKind.DeclareKeyword

| SyntaxKind.DefaultKeyword

| SyntaxKind.DeleteKeyword

| SyntaxKind.DoKeyword

| SyntaxKind.ElseKeyword

| SyntaxKind.EnumKeyword

| SyntaxKind.ExportKeyword

| SyntaxKind.ExtendsKeyword

| SyntaxKind.FalseKeyword

| SyntaxKind.FinallyKeyword

| SyntaxKind.ForKeyword

| SyntaxKind.FromKeyword

| SyntaxKind.FunctionKeyword

| SyntaxKind.GetKeyword

| SyntaxKind.GlobalKeyword

| SyntaxKind.IfKeyword

| SyntaxKind.ImplementsKeyword

| SyntaxKind.ImportKeyword

| SyntaxKind.InferKeyword

| SyntaxKind.InKeyword

| SyntaxKind.InstanceOfKeyword

| SyntaxKind.InterfaceKeyword

| SyntaxKind.IntrinsicKeyword

| SyntaxKind.IsKeyword

| SyntaxKind.KeyOfKeyword

| SyntaxKind.LetKeyword

| SyntaxKind.ModuleKeyword

| SyntaxKind.NamespaceKeyword

| SyntaxKind.NeverKeyword

| SyntaxKind.NewKeyword

| SyntaxKind.NullKeyword

| SyntaxKind.NumberKeyword

| SyntaxKind.ObjectKeyword

| SyntaxKind.OfKeyword

| SyntaxKind.PackageKeyword

| SyntaxKind.PrivateKeyword

| SyntaxKind.ProtectedKeyword

| SyntaxKind.PublicKeyword

| SyntaxKind.ReadonlyKeyword

| SyntaxKind.OverrideKeyword

| SyntaxKind.RequireKeyword

| SyntaxKind.ReturnKeyword

| SyntaxKind.SetKeyword

| SyntaxKind.StaticKeyword

| SyntaxKind.StringKeyword

| SyntaxKind.SuperKeyword

| SyntaxKind.SwitchKeyword

| SyntaxKind.SymbolKeyword

| SyntaxKind.ThisKeyword

| SyntaxKind.ThrowKeyword

| SyntaxKind.TrueKeyword

| SyntaxKind.TryKeyword

| SyntaxKind.TypeKeyword

| SyntaxKind.TypeOfKeyword

| SyntaxKind.UndefinedKeyword

| SyntaxKind.UniqueKeyword

| SyntaxKind.UnknownKeyword

| SyntaxKind.VarKeyword

| SyntaxKind.VoidKeyword

| SyntaxKind.WhileKeyword

| SyntaxKind.WithKeyword

| SyntaxKind.YieldKeyword

;

export type ModifierSyntaxKind =

| SyntaxKind.AbstractKeyword

| SyntaxKind.AsyncKeyword

| SyntaxKind.ConstKeyword

| SyntaxKind.DeclareKeyword

| SyntaxKind.DefaultKeyword

| SyntaxKind.ExportKeyword

| SyntaxKind.PrivateKeyword

| SyntaxKind.ProtectedKeyword

| SyntaxKind.PublicKeyword

| SyntaxKind.ReadonlyKeyword

| SyntaxKind.OverrideKeyword

| SyntaxKind.StaticKeyword

;

export type KeywordTypeSyntaxKind =

| SyntaxKind.AnyKeyword

| SyntaxKind.BigIntKeyword

| SyntaxKind.BooleanKeyword

| SyntaxKind.IntrinsicKeyword

| SyntaxKind.NeverKeyword

| SyntaxKind.NumberKeyword

| SyntaxKind.ObjectKeyword

| SyntaxKind.StringKeyword

| SyntaxKind.SymbolKeyword

| SyntaxKind.UndefinedKeyword

| SyntaxKind.UnknownKeyword

| SyntaxKind.VoidKeyword

;

/* @internal */

export type TypeNodeSyntaxKind =

| KeywordTypeSyntaxKind

| SyntaxKind.TypePredicate

| SyntaxKind.TypeReference

| SyntaxKind.FunctionType

| SyntaxKind.ConstructorType

| SyntaxKind.TypeQuery

| SyntaxKind.TypeLiteral

| SyntaxKind.ArrayType

| SyntaxKind.TupleType

| SyntaxKind.NamedTupleMember

| SyntaxKind.OptionalType

| SyntaxKind.RestType

| SyntaxKind.UnionType

| SyntaxKind.IntersectionType

| SyntaxKind.ConditionalType

| SyntaxKind.InferType

| SyntaxKind.ParenthesizedType

| SyntaxKind.ThisType

| SyntaxKind.TypeOperator

| SyntaxKind.IndexedAccessType

| SyntaxKind.MappedType

| SyntaxKind.LiteralType

| SyntaxKind.TemplateLiteralType

| SyntaxKind.TemplateLiteralTypeSpan

| SyntaxKind.ImportType

| SyntaxKind.ExpressionWithTypeArguments

| SyntaxKind.JSDocTypeExpression

| SyntaxKind.JSDocAllType

| SyntaxKind.JSDocUnknownType

| SyntaxKind.JSDocNonNullableType

| SyntaxKind.JSDocNullableType

| SyntaxKind.JSDocOptionalType

| SyntaxKind.JSDocFunctionType

| SyntaxKind.JSDocVariadicType

| SyntaxKind.JSDocNamepathType

| SyntaxKind.JSDocSignature

| SyntaxKind.JSDocTypeLiteral

;

export type TokenSyntaxKind =

| SyntaxKind.Unknown

| SyntaxKind.EndOfFileToken

| TriviaSyntaxKind

| LiteralSyntaxKind

| PseudoLiteralSyntaxKind

| PunctuationSyntaxKind

| SyntaxKind.Identifier

| KeywordSyntaxKind

;

export type JsxTokenSyntaxKind =

| SyntaxKind.LessThanSlashToken

| SyntaxKind.EndOfFileToken

| SyntaxKind.ConflictMarkerTrivia

| SyntaxKind.JsxText

| SyntaxKind.JsxTextAllWhiteSpaces

| SyntaxKind.OpenBraceToken

| SyntaxKind.LessThanToken

;

export type JSDocSyntaxKind =

| SyntaxKind.EndOfFileToken

| SyntaxKind.WhitespaceTrivia

| SyntaxKind.AtToken

| SyntaxKind.NewLineTrivia

| SyntaxKind.AsteriskToken

| SyntaxKind.OpenBraceToken

| SyntaxKind.CloseBraceToken

| SyntaxKind.LessThanToken

| SyntaxKind.GreaterThanToken

| SyntaxKind.OpenBracketToken

| SyntaxKind.CloseBracketToken

| SyntaxKind.EqualsToken

| SyntaxKind.CommaToken

| SyntaxKind.DotToken

| SyntaxKind.Identifier

| SyntaxKind.BacktickToken

| SyntaxKind.Unknown

| KeywordSyntaxKind

;

export const enum NodeFlags {

None = 0,

Let = 1 << 0, // Variable declaration

Const = 1 << 1, // Variable declaration

NestedNamespace = 1 << 2, // Namespace declaration

Synthesized = 1 << 3, // Node was synthesized during transformation

Namespace = 1 << 4, // Namespace declaration

OptionalChain = 1 << 5, // Chained MemberExpression rooted to a pseudo-OptionalExpression

ExportContext = 1 << 6, // Export context (initialized by binding)

ContainsThis = 1 << 7, // Interface contains references to "this"

HasImplicitReturn = 1 << 8, // If function implicitly returns on one of codepaths (initialized by binding)

HasExplicitReturn = 1 << 9, // If function has explicit reachable return on one of codepaths (initialized by binding)

GlobalAugmentation = 1 << 10, // Set if module declaration is an augmentation for the global scope

HasAsyncFunctions = 1 << 11, // If the file has async functions (initialized by binding)

DisallowInContext = 1 << 12, // If node was parsed in a context where 'in-expressions' are not allowed

YieldContext = 1 << 13, // If node was parsed in the 'yield' context created when parsing a generator

DecoratorContext = 1 << 14, // If node was parsed as part of a decorator

AwaitContext = 1 << 15, // If node was parsed in the 'await' context created when parsing an async function

ThisNodeHasError = 1 << 16, // If the parser encountered an error when parsing the code that created this node

JavaScriptFile = 1 << 17, // If node was parsed in a JavaScript

ThisNodeOrAnySubNodesHasError = 1 << 18, // If this node or any of its children had an error

HasAggregatedChildData = 1 << 19, // If we've computed data from children and cached it in this node

// These flags will be set when the parser encounters a dynamic import expression or 'import.meta' to avoid

// walking the tree if the flags are not set. However, these flags are just a approximation

// (hence why it's named "PossiblyContainsDynamicImport") because once set, the flags never get cleared.

// During editing, if a dynamic import is removed, incremental parsing will *NOT* clear this flag.

// This means that the tree will always be traversed during module resolution, or when looking for external module indicators.

// However, the removal operation should not occur often and in the case of the

// removal, it is likely that users will add the import anyway.

// The advantage of this approach is its simplicity. For the case of batch compilation,

// we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used.

/* @internal */ PossiblyContainsDynamicImport = 1 << 20,

/* @internal */ PossiblyContainsImportMeta = 1 << 21,

JSDoc = 1 << 22, // If node was parsed inside jsdoc

/* @internal */ Ambient = 1 << 23, // If node was inside an ambient context -- a declaration file, or inside something with the `declare` modifier.

/* @internal */ InWithStatement = 1 << 24, // If any ancestor of node was the `statement` of a WithStatement (not the `expression`)

JsonFile = 1 << 25, // If node was parsed in a Json

/* @internal */ TypeCached = 1 << 26, // If a type was cached for node at any point

/* @internal */ Deprecated = 1 << 27, // If has '@deprecated' JSDoc tag

BlockScoped = Let | Const,

ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,

ReachabilityAndEmitFlags = ReachabilityCheckFlags | HasAsyncFunctions,

// Parsing context flags

ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile | InWithStatement | Ambient,

// Exclude these flags when parsing a Type

TypeExcludesFlags = YieldContext | AwaitContext,

// Represents all flags that are potentially set once and

// never cleared on SourceFiles which get re-used in between incremental parses.

// See the comment above on `PossiblyContainsDynamicImport` and `PossiblyContainsImportMeta`.

/* @internal */ PermanentlySetIncrementalFlags = PossiblyContainsDynamicImport | PossiblyContainsImportMeta,

}

export const enum ModifierFlags {

None = 0,

Export = 1 << 0, // Declarations

Ambient = 1 << 1, // Declarations

Public = 1 << 2, // Property/Method

Private = 1 << 3, // Property/Method

Protected = 1 << 4, // Property/Method

Static = 1 << 5, // Property/Method

Readonly = 1 << 6, // Property/Method

Abstract = 1 << 7, // Class/Method/ConstructSignature

Async = 1 << 8, // Property/Method/Function

Default = 1 << 9, // Function/Class (export default declaration)

Const = 1 << 11, // Const enum

HasComputedJSDocModifiers = 1 << 12, // Indicates the computed modifier flags include modifiers from JSDoc.

Deprecated = 1 << 13, // Deprecated tag.

Override = 1 << 14, // Override method.

HasComputedFlags = 1 << 29, // Modifier flags have been computed

AccessibilityModifier = Public | Private | Protected,

// Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property.

ParameterPropertyModifier = AccessibilityModifier | Readonly,

NonPublicAccessibilityModifier = Private | Protected,

TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const | Override,

ExportDefault = Export | Default,

All = Export | Ambient | Public | Private | Protected | Static | Readonly | Abstract | Async | Default | Const | Deprecated | Override

}

export const enum JsxFlags {

None = 0,

/** An element from a named property of the JSX.IntrinsicElements interface */

IntrinsicNamedElement = 1 << 0,

/** An element inferred from the string index signature of the JSX.IntrinsicElements interface */

IntrinsicIndexedElement = 1 << 1,

IntrinsicElement = IntrinsicNamedElement | IntrinsicIndexedElement,

}

/* @internal */

export const enum RelationComparisonResult {

Succeeded = 1 << 0, // Should be truthy

Failed = 1 << 1,

Reported = 1 << 2,

ReportsUnmeasurable = 1 << 3,

ReportsUnreliable = 1 << 4,

ReportsMask = ReportsUnmeasurable | ReportsUnreliable

}

/* @internal */

export type NodeId = number;

export interface Node extends ReadonlyTextRange {

readonly kind: SyntaxKind;

readonly flags: NodeFlags;

/* @internal */ modifierFlagsCache: ModifierFlags;

/* @internal */ readonly transformFlags: TransformFlags; // Flags for transforms

readonly decorators?: NodeArray<Decorator>; // Array of decorators (in document order)

readonly modifiers?: ModifiersArray; // Array of modifiers

/* @internal */ id?: NodeId; // Unique id (used to look up NodeLinks)

readonly parent: Node; // Parent node (initialized by binding)

/* @internal */ original?: Node; // The original node if this is an updated node.

/* @internal */ symbol: Symbol; // Symbol declared by node (initialized by binding)

/* @internal */ locals?: SymbolTable; // Locals associated with node (initialized by binding)

/* @internal */ nextContainer?: Node; // Next container in declaration order (initialized by binding)

/* @internal */ localSymbol?: Symbol; // Local symbol declared by node (initialized by binding only for exported nodes)

/* @internal */ flowNode?: FlowNode; // Associated FlowNode (initialized by binding)

/* @internal */ emitNode?: EmitNode; // Associated EmitNode (initialized by transforms)

/* @internal */ contextualType?: Type; // Used to temporarily assign a contextual type during overload resolution

/* @internal */ inferenceContext?: InferenceContext; // Inference context for contextual type

}

export interface JSDocContainer {

/* @internal */ jsDoc?: JSDoc[]; // JSDoc that directly precedes this node

/* @internal */ jsDocCache?: readonly JSDocTag[]; // Cache for getJSDocTags

}

export type HasJSDoc =

| ParameterDeclaration

| CallSignatureDeclaration

| ConstructSignatureDeclaration

| MethodSignature

| PropertySignature

| ArrowFunction

| ParenthesizedExpression

| SpreadAssignment

| ShorthandPropertyAssignment

| PropertyAssignment

| FunctionExpression

| LabeledStatement

| ExpressionStatement

| VariableStatement

| FunctionDeclaration

| ConstructorDeclaration

| MethodDeclaration

| VariableDeclaration

| PropertyDeclaration

| AccessorDeclaration

| ClassLikeDeclaration

| InterfaceDeclaration

| TypeAliasDeclaration

| EnumMember

| EnumDeclaration

| ModuleDeclaration

| ImportEqualsDeclaration

| ImportDeclaration

| NamespaceExportDeclaration

| ExportAssignment

| IndexSignatureDeclaration

| FunctionTypeNode

| ConstructorTypeNode

| JSDocFunctionType

| ExportDeclaration

| NamedTupleMember

| EndOfFileToken

;

export type HasType =

| SignatureDeclaration

| VariableDeclaration

| ParameterDeclaration

| PropertySignature

| PropertyDeclaration

| TypePredicateNode

| ParenthesizedTypeNode

| TypeOperatorNode

| MappedTypeNode

| AssertionExpression

| TypeAliasDeclaration

| JSDocTypeExpression

| JSDocNonNullableType

| JSDocNullableType

| JSDocOptionalType

| JSDocVariadicType

;

export type HasTypeArguments =

| CallExpression

| NewExpression

| TaggedTemplateExpression

| JsxOpeningElement

| JsxSelfClosingElement;

export type HasInitializer =

| HasExpressionInitializer

| ForStatement

| ForInStatement

| ForOfStatement

| JsxAttribute

;

export type HasExpressionInitializer =

| VariableDeclaration

| ParameterDeclaration

| BindingElement

| PropertySignature

| PropertyDeclaration

| PropertyAssignment

| EnumMember

;

// NOTE: Changing this list requires changes to `canHaveModifiers` in factory/utilities.ts and `updateModifiers` in factory/nodeFactory.ts

/* @internal */

export type HasModifiers =

| ParameterDeclaration

| PropertySignature

| PropertyDeclaration

| MethodSignature

| MethodDeclaration

| ConstructorDeclaration

| GetAccessorDeclaration

| SetAccessorDeclaration

| IndexSignatureDeclaration

| FunctionExpression

| ArrowFunction

| ClassExpression

| VariableStatement

| FunctionDeclaration

| ClassDeclaration

| InterfaceDeclaration

| TypeAliasDeclaration

| EnumDeclaration

| ModuleDeclaration

| ImportEqualsDeclaration

| ImportDeclaration

| ExportAssignment

| ExportDeclaration

;

/* @internal */

export type MutableNodeArray<T extends Node> = NodeArray<T> & T[];

export interface NodeArray<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange {

hasTrailingComma?: boolean;

/* @internal */ transformFlags: TransformFlags; // Flags for transforms, possibly undefined

}

// TODO(rbuckton): Constraint 'TKind' to 'TokenSyntaxKind'

export interface Token<TKind extends SyntaxKind> extends Node {

readonly kind: TKind;

}

export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & JSDocContainer;

// Punctuation

export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {

}

export type DotToken = PunctuationToken<SyntaxKind.DotToken>;

export type DotDotDotToken = PunctuationToken<SyntaxKind.DotDotDotToken>;

export type QuestionToken = PunctuationToken<SyntaxKind.QuestionToken>;

export type ExclamationToken = PunctuationToken<SyntaxKind.ExclamationToken>;