jtscript

/*! ***************************************************************************** Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT. See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ /*! ***************************************************************************** Copyright (c) 2018 - 2022 Zhou Dengxiang. All rights reserved. ***************************************************************************** */ declare namespace ts { const versionMajorMinor = "4.3"; /** The version of the TypeScript compiler release */ const version: string; /** * Type of objects whose values are all of the same type. * The `in` and `for-in` operators can *not* be safely used, * since `Object.prototype` may be modified by outside code. */ interface MapLike<T> { [index: string]: T; } interface SortedReadonlyArray<T> extends ReadonlyArray<T> { " __sortedArrayBrand": any; } interface SortedArray<T> extends Array<T> { " __sortedArrayBrand": any; } /** Common read methods for ES6 Map/Set. */ interface ReadonlyCollection<K> { readonly size: number; has(key: K): boolean; keys(): Iterator<K>; } /** Common write methods for ES6 Map/Set. */ interface Collection<K> extends ReadonlyCollection<K> { delete(key: K): boolean; clear(): void; } /** ES6 Map interface, only read methods included. */ interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> { get(key: K): V | undefined; values(): Iterator<V>; entries(): Iterator<[K, V]>; forEach(action: (value: V, key: K) => void): void; } /** * ES6 Map interface, only read methods included. */ interface ReadonlyMap<T> extends ReadonlyESMap<string, T> { } /** ES6 Map interface. */ interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> { set(key: K, value: V): this; } /** * ES6 Map interface. */ interface Map<T> extends ESMap<string, T> { } /** ES6 Set interface, only read methods included. */ interface ReadonlySet<T> extends ReadonlyCollection<T> { has(value: T): boolean; values(): Iterator<T>; entries(): Iterator<[T, T]>; forEach(action: (value: T, key: T) => void): void; } /** ES6 Set interface. */ interface Set<T> extends ReadonlySet<T>, Collection<T> { add(value: T): this; delete(value: T): boolean; } /** ES6 Iterator type. */ interface Iterator<T> { next(): { value: T; done?: false; } | { value: void; done: true; }; } /** Array that is only intended to be pushed to, never read. */ interface Push<T> { push(...values: T[]): void; } } declare namespace ts { export type Path = string & { __pathBrand: any; }; export interface TextRange { pos: number; end: number; } export interface ReadonlyTextRange { readonly pos: number; readonly end: number; } export enum SyntaxKind { Unknown = 0, EndOfFileToken = 1, SingleLineCommentTrivia = 2, MultiLineCommentTrivia = 3, NewLineTrivia = 5, WhitespaceTrivia = 6, ShebangTrivia = 7, ConflictMarkerTrivia = 8, NumericLiteral = 9, BigIntLiteral = 10, StringLiteral = 11, JsxText = 12, JsxTextAllWhiteSpaces = 13, RegularExpressionLiteral = 14, NoSubstitutionTemplateLiteral = 15, TemplateHead = 16, TemplateMiddle = 17, TemplateTail = 18, OpenBraceToken = 19, CloseBraceToken = 20, OpenParenToken = 21, CloseParenToken = 22, OpenBracketToken = 23, CloseBracketToken = 24, DotToken = 25, DotDotDotToken = 26, SemicolonToken = 27, CommaToken = 28, QuestionDotToken = 29, LessThanToken = 30, LessThanSlashToken = 31, GreaterThanToken = 32, LessThanEqualsToken = 33, GreaterThanEqualsToken = 34, EqualsEqualsToken = 35, ExclamationEqualsToken = 36, EqualsEqualsEqualsToken = 37, ExclamationEqualsEqualsToken = 38, EqualsGreaterThanToken = 39, PlusToken = 40, MinusToken = 41, AsteriskToken = 42, AsteriskAsteriskToken = 43, SlashToken = 44, PercentToken = 45, PlusPlusToken = 46, MinusMinusToken = 47, LessThanLessThanToken = 48, GreaterThanGreaterThanToken = 49, GreaterThanGreaterThanGreaterThanToken = 50, AmpersandToken = 51, BarToken = 52, CaretToken = 53, ExclamationToken = 54, TildeToken = 55, AmpersandAmpersandToken = 56, BarBarToken = 57, QuestionToken = 58, ColonToken = 59, AtToken = 60, QuestionQuestionToken = 61, /** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */ BacktickToken = 62, EqualsToken = 63, PlusEqualsToken = 64, MinusEqualsToken = 65, AsteriskEqualsToken = 66, AsteriskAsteriskEqualsToken = 67, SlashEqualsToken = 68, PercentEqualsToken = 69, LessThanLessThanEqualsToken = 70, GreaterThanGreaterThanEqualsToken = 71, GreaterThanGreaterThanGreaterThanEqualsToken = 72, AmpersandEqualsToken = 73, BarEqualsToken = 74, BarBarEqualsToken = 75, AmpersandAmpersandEqualsToken = 76, QuestionQuestionEqualsToken = 77, CaretEqualsToken = 78, Identifier = 79, PrivateIdentifier = 80, BreakKeyword = 81, CaseKeyword = 82, CatchKeyword = 83, ClassKeyword = 84, ConstKeyword = 85, ContinueKeyword = 86, DebuggerKeyword = 87, DefaultKeyword = 88, DeleteKeyword = 89, DoKeyword = 90, ElseKeyword = 91, EnumKeyword = 92, ExportKeyword = 93, ExtendsKeyword = 94, FalseKeyword = 95, FinallyKeyword = 96, ForKeyword = 97, FunctionKeyword = 98, IfKeyword = 99, ImportKeyword = 100, InKeyword = 101, InstanceOfKeyword = 102, NewKeyword = 103, NullKeyword = 104, ReturnKeyword = 105, SuperKeyword = 106, SwitchKeyword = 107, ThisKeyword = 108, ThrowKeyword = 109, TrueKeyword = 110, TryKeyword = 111, TypeOfKeyword = 112, VarKeyword = 113, VoidKeyword = 114, WhileKeyword = 115, WithKeyword = 116, ImplementsKeyword = 117, InterfaceKeyword = 118, LetKeyword = 119, PackageKeyword = 120, PrivateKeyword = 121, ProtectedKeyword = 122, PublicKeyword = 123, StaticKeyword = 124, YieldKeyword = 125, AbstractKeyword = 126, AsKeyword = 127, AssertsKeyword = 128, AnyKeyword = 129, AsyncKeyword = 130, AwaitKeyword = 131, BooleanKeyword = 132, ConstructorKeyword = 133, DeclareKeyword = 134, GetKeyword = 135, InferKeyword = 136, IntrinsicKeyword = 137, IsKeyword = 138, KeyOfKeyword = 139, ModuleKeyword = 140, NamespaceKeyword = 141, NeverKeyword = 142, ReadonlyKeyword = 143, RequireKeyword = 144, NumberKeyword = 145, ObjectKeyword = 146, SetKeyword = 147, StringKeyword = 148, SymbolKeyword = 149, TypeKeyword = 150, UndefinedKeyword = 151, UniqueKeyword = 152, UnknownKeyword = 153, FromKeyword = 154, GlobalKeyword = 155, BigIntKeyword = 156, OverrideKeyword = 157, OfKeyword = 158, QualifiedName = 159, ComputedPropertyName = 160, TypeParameter = 161, Parameter = 162, Decorator = 163, PropertySignature = 164, PropertyDeclaration = 165, MethodSignature = 166, MethodDeclaration = 167, Constructor = 168, GetAccessor = 169, SetAccessor = 170, CallSignature = 171, ConstructSignature = 172, IndexSignature = 173, TypePredicate = 174, TypeReference = 175, FunctionType = 176, ConstructorType = 177, TypeQuery = 178, TypeLiteral = 179, ArrayType = 180, TupleType = 181, OptionalType = 182, RestType = 183, UnionType = 184, IntersectionType = 185, ConditionalType = 186, InferType = 187, ParenthesizedType = 188, ThisType = 189, TypeOperator = 190, IndexedAccessType = 191, MappedType = 192, LiteralType = 193, NamedTupleMember = 194, TemplateLiteralType = 195, TemplateLiteralTypeSpan = 196, ImportType = 197, ObjectBindingPattern = 198, ArrayBindingPattern = 199, BindingElement = 200, ArrayLiteralExpression = 201, ObjectLiteralExpression = 202, PropertyAccessExpression = 203, ElementAccessExpression = 204, CallExpression = 205, NewExpression = 206, TaggedTemplateExpression = 207, TypeAssertionExpression = 208, ParenthesizedExpression = 209, FunctionExpression = 210, ArrowFunction = 211, DeleteExpression = 212, TypeOfExpression = 213, VoidExpression = 214, AwaitExpression = 215, PrefixUnaryExpression = 216, PostfixUnaryExpression = 217, BinaryExpression = 218, ConditionalExpression = 219, TemplateExpression = 220, YieldExpression = 221, SpreadElement = 222, ClassExpression = 223, OmittedExpression = 224, ExpressionWithTypeArguments = 225, AsExpression = 226, NonNullExpression = 227, MetaProperty = 228, SyntheticExpression = 229, TemplateSpan = 230, SemicolonClassElement = 231, Block = 232, EmptyStatement = 233, VariableStatement = 234, ExpressionStatement = 235, IfStatement = 236, DoStatement = 237, WhileStatement = 238, ForStatement = 239, ForInStatement = 240, ForOfStatement = 241, ContinueStatement = 242, BreakStatement = 243, ReturnStatement = 244, WithStatement = 245, SwitchStatement = 246, LabeledStatement = 247, ThrowStatement = 248, TryStatement = 249, DebuggerStatement = 250, VariableDeclaration = 251, VariableDeclarationList = 252, FunctionDeclaration = 253, ClassDeclaration = 254, InterfaceDeclaration = 255, TypeAliasDeclaration = 256, EnumDeclaration = 257, ModuleDeclaration = 258, ModuleBlock = 259, CaseBlock = 260, NamespaceExportDeclaration = 261, ImportEqualsDeclaration = 262, ImportDeclaration = 263, ImportClause = 264, NamespaceImport = 265, NamedImports = 266, ImportSpecifier = 267, ExportAssignment = 268, ExportDeclaration = 269, NamedExports = 270, NamespaceExport = 271, ExportSpecifier = 272, MissingDeclaration = 273, ExternalModuleReference = 274, JsxElement = 275, JsxSelfClosingElement = 276, JsxOpeningElement = 277, JsxClosingElement = 278, JsxFragment = 279, JsxOpeningFragment = 280, JsxClosingFragment = 281, JsxAttribute = 282, JsxAttributes = 283, JsxSpreadAttribute = 284, JsxExpression = 285, CaseClause = 286, DefaultClause = 287, HeritageClause = 288, CatchClause = 289, PropertyAssignment = 290, ShorthandPropertyAssignment = 291, SpreadAssignment = 292, EnumMember = 293, UnparsedPrologue = 294, UnparsedPrepend = 295, UnparsedText = 296, UnparsedInternalText = 297, UnparsedSyntheticReference = 298, SourceFile = 299, Bundle = 300, UnparsedSource = 301, InputFiles = 302, JSDocTypeExpression = 303, JSDocNameReference = 304, JSDocAllType = 305, JSDocUnknownType = 306, JSDocNullableType = 307, JSDocNonNullableType = 308, JSDocOptionalType = 309, JSDocFunctionType = 310, JSDocVariadicType = 311, JSDocNamepathType = 312, JSDocComment = 313, JSDocText = 314, JSDocTypeLiteral = 315, JSDocSignature = 316, JSDocLink = 317, JSDocTag = 318, JSDocAugmentsTag = 319, JSDocImplementsTag = 320, JSDocAuthorTag = 321, JSDocDeprecatedTag = 322, JSDocClassTag = 323, JSDocPublicTag = 324, JSDocPrivateTag = 325, JSDocProtectedTag = 326, JSDocReadonlyTag = 327, JSDocOverrideTag = 328, JSDocCallbackTag = 329, JSDocEnumTag = 330, JSDocParameterTag = 331, JSDocReturnTag = 332, JSDocThisTag = 333, JSDocTypeTag = 334, JSDocTemplateTag = 335, JSDocTypedefTag = 336, JSDocSeeTag = 337, JSDocPropertyTag = 338, SyntaxList = 339, NotEmittedStatement = 340, PartiallyEmittedExpression = 341, CommaListExpression = 342, MergeDeclarationMarker = 343, EndOfDeclarationMarker = 344, SyntheticReferenceExpression = 345, Count = 346, FirstAssignment = 63, LastAssignment = 78, FirstCompoundAssignment = 64, LastCompoundAssignment = 78, FirstReservedWord = 81, LastReservedWord = 116, FirstKeyword = 81, LastKeyword = 158, FirstFutureReservedWord = 117, LastFutureReservedWord = 125, FirstTypeNode = 174, LastTypeNode = 197, FirstPunctuation = 19, LastPunctuation = 78, FirstToken = 0, LastToken = 158, FirstTriviaToken = 2, LastTriviaToken = 8, FirstLiteralToken = 9, LastLiteralToken = 15, FirstTemplateToken = 15, LastTemplateToken = 18, FirstBinaryOperator = 30, LastBinaryOperator = 78, FirstStatement = 234, LastStatement = 250, FirstNode = 159, FirstJSDocNode = 303, LastJSDocNode = 338, FirstJSDocTagNode = 318, LastJSDocTagNode = 338, } 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; 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 enum NodeFlags { None = 0, Let = 1, Const = 2, NestedNamespace = 4, Synthesized = 8, Namespace = 16, OptionalChain = 32, ExportContext = 64, ContainsThis = 128, HasImplicitReturn = 256, HasExplicitReturn = 512, GlobalAugmentation = 1024, HasAsyncFunctions = 2048, DisallowInContext = 4096, YieldContext = 8192, DecoratorContext = 16384, AwaitContext = 32768, ThisNodeHasError = 65536, JavaScriptFile = 131072, ThisNodeOrAnySubNodesHasError = 262144, HasAggregatedChildData = 524288, JSDoc = 4194304, JsonFile = 33554432, BlockScoped = 3, ReachabilityCheckFlags = 768, ReachabilityAndEmitFlags = 2816, ContextFlags = 25358336, TypeExcludesFlags = 40960, } export enum ModifierFlags { None = 0, Export = 1, Ambient = 2, Public = 4, Private = 8, Protected = 16, Static = 32, Readonly = 64, Abstract = 128, Async = 256, Default = 512, Const = 2048, HasComputedJSDocModifiers = 4096, Deprecated = 8192, Override = 16384, HasComputedFlags = 536870912, AccessibilityModifier = 28, ParameterPropertyModifier = 16476, NonPublicAccessibilityModifier = 24, TypeScriptModifier = 18654, ExportDefault = 513, All = 27647 } export enum JsxFlags { None = 0, /** An element from a named property of the JSX.IntrinsicElements interface */ IntrinsicNamedElement = 1, /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */ IntrinsicIndexedElement = 2, IntrinsicElement = 3 } export interface Node extends ReadonlyTextRange { readonly kind: SyntaxKind; readonly flags: NodeFlags; originType?: Type; readonly decorators?: NodeArray<Decorator>; readonly modifiers?: ModifiersArray; readonly parent: Node; } export interface JSDocContainer { } export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | EmptyStatement | DebuggerStatement | Block | VariableStatement | ExpressionStatement | IfStatement | DoStatement | WhileStatement | ForStatement | ForInStatement | ForOfStatement | BreakStatement | ContinueStatement | ReturnStatement | WithStatement | SwitchStatement | LabeledStatement | ThrowStatement | TryStatement | 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; export interface NodeArray<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange { hasTrailingComma?: boolean; } export interface Token<TKind extends SyntaxKind> extends Node { readonly kind: TKind; } export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & JSDocContainer; 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>; export type ColonToken = PunctuationToken<SyntaxKind.ColonToken>; export type EqualsToken = PunctuationToken<SyntaxKind.EqualsToken>; export type AsteriskToken = PunctuationToken<SyntaxKind.AsteriskToken>; export type EqualsGreaterThanToken = PunctuationToken<SyntaxKind.EqualsGreaterThanToken>; export type PlusToken = PunctuationToken<SyntaxKind.PlusToken>; export type MinusToken = PunctuationToken<SyntaxKind.MinusToken>; export type QuestionDotToken = PunctuationToken<SyntaxKind.QuestionDotToken>; export interface KeywordToken<TKind extends KeywordSyntaxKind> extends Token<TKind> { } export type AssertsKeyword = KeywordToken<SyntaxKind.AssertsKeyword>; export type AwaitKeyword = KeywordToken<SyntaxKind.AwaitKeyword>; /** @deprecated Use `AwaitKeyword` instead. */ export type AwaitKeywordToken = AwaitKeyword; /** @deprecated Use `AssertsKeyword` instead. */ export type AssertsToken = AssertsKeyword; export interface ModifierToken<TKind extends ModifierSyntaxKind> extends KeywordToken<TKind> { } export type AbstractKeyword = ModifierToken<SyntaxKind.AbstractKeyword>; export type AsyncKeyword = ModifierToken<SyntaxKind.AsyncKeyword>; export type ConstKeyword = ModifierToken<SyntaxKind.ConstKeyword>; export type DeclareKeyword = ModifierToken<SyntaxKind.DeclareKeyword>; export type DefaultKeyword = ModifierToken<SyntaxKind.DefaultKeyword>; export type ExportKeyword = ModifierToken<SyntaxKind.ExportKeyword>; export type PrivateKeyword = ModifierToken<SyntaxKind.PrivateKeyword>; export type ProtectedKeyword = ModifierToken<SyntaxKind.ProtectedKeyword>; export type PublicKeyword = ModifierToken<SyntaxKind.PublicKeyword>; export type ReadonlyKeyword = ModifierToken<SyntaxKind.ReadonlyKeyword>; export type OverrideKeyword = ModifierToken<SyntaxKind.OverrideKeyword>; export type StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>; /** @deprecated Use `ReadonlyKeyword` instead. */ export type ReadonlyToken = ReadonlyKeyword; export type Modifier = AbstractKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword; export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword; export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword; export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword; export type ModifiersArray = NodeArray<Modifier>; export enum GeneratedIdentifierFlags { None = 0, ReservedInNestedScopes = 8, Optimistic = 16, FileLevel = 32, AllowNameSubstitution = 64 } export interface Identifier extends PrimaryExpression, Declaration { readonly kind: SyntaxKind.Identifier; /** * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.) * Text of identifier, but if the identifier begins with two underscores, this will begin with three. */ readonly escapedText: __String; readonly originalKeywordKind?: SyntaxKind; isInJSDocNamespace?: boolean; } export interface TransientIdentifier extends Identifier { resolvedSymbol: Symbol; } export interface QualifiedName extends Node { readonly kind: SyntaxKind.QualifiedName; readonly left: EntityName; readonly right: Identifier; } export type EntityName = Identifier | QualifiedName; export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier; export type MemberName = Identifier | PrivateIdentifier; export type DeclarationName = Identifier | PrivateIdentifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern | EntityNameExpression; export interface Declaration extends Node { _declarationBrand: any; } export interface NamedDeclaration extends Declaration { readonly name?: DeclarationName; } export interface DeclarationStatement extends NamedDeclaration, Statement { readonly name?: Identifier | StringLiteral | NumericLiteral; } export interface ComputedPropertyName extends Node { readonly kind: SyntaxKind.ComputedPropertyName; readonly parent: Declaration; readonly expression: Expression; } export interface PrivateIdentifier extends Node { readonly kind: SyntaxKind.PrivateIdentifier; readonly escapedText: __String; } export interface Decorator extends Node { readonly kind: SyntaxKind.Decorator; readonly parent: NamedDeclaration; readonly expression: LeftHandSideExpression; } export interface TypeParameterDeclaration extends NamedDeclaration { readonly kind: SyntaxKind.TypeParameter; readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode; readonly name: Identifier; /** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */ readonly constraint?: TypeNode; readonly default?: TypeNode; expression?: Expression; } export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer { readonly kind: SignatureDeclaration["kind"]; readonly name?: PropertyName; readonly typeParameters?: NodeArray<TypeParameterDeclaration>; readonly parameters: NodeArray<ParameterDeclaration>; readonly type?: TypeNode; } export type SignatureDeclaration = CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | AccessorDeclaration | FunctionExpression | ArrowFunction; export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement { readonly kind: SyntaxKind.CallSignature; } export interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement { readonly kind: SyntaxKind.ConstructSignature; } export type BindingName = Identifier | BindingPattern; export interface VariableDeclaration extends NamedDeclaration, JSDocContainer { readonly kind: SyntaxKind.VariableDeclaration; readonly parent: VariableDeclarationList | CatchClause; readonly name: BindingName; readonly exclamationToken?: ExclamationToken; readonly type?: TypeNode; readonly initializer?: Expression; } export interface VariableDeclarationList extends Node { readonly kind: SyntaxKind.VariableDeclarationList; readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement; readonly declarations: NodeArray<VariableDeclaration>; } export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer { readonly kind: SyntaxKind.Parameter; readonly parent: SignatureDeclaration; readonly dotDotDotToken?: DotDotDotToken; readonly name: BindingName; readonly questionToken?: QuestionToken; readonly type?: TypeNode; readonly initializer?: Expression; } export interface BindingElement extends NamedDeclaration { readonly kind: SyntaxKind.BindingElement; readonly parent: BindingPattern; readonly propertyName?: PropertyName; readonly dotDotDotToken?: DotDotDotToken; readonly name: BindingName; readonly initializer?: Expression; } export interface PropertySignature extends TypeElement, JSDocContainer { readonly kind: SyntaxKind.PropertySignature; readonly name: PropertyName; readonly questionToken?: QuestionToken; readonly type?: TypeNode; initializer?: Expression; } export interface PropertyDeclaration extends ClassElement, JSDocContainer { readonly kind: SyntaxKind.PropertyDeclaration; readonly parent: ClassLikeDeclaration; readonly name: PropertyName; readonly questionToken?: QuestionToken; readonly exclamationToken?: ExclamationToken; readonly type?: TypeNode; readonly initializer?: Expression; } export interface ObjectLiteralElement extends NamedDeclaration { _objectLiteralBrand: any; readonly name?: PropertyName; } /** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */ export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration; export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.PropertyAssignment; readonly parent: ObjectLiteralExpression; readonly name: PropertyName; readonly questionToken?: QuestionToken; readonly exclamationToken?: ExclamationToken; readonly initializer: Expression; } export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.ShorthandPropertyAssignment; readonly parent: ObjectLiteralExpression; readonly name: Identifier; readonly questionToken?: QuestionToken; readonly exclamationToken?: ExclamationToken; readonly equalsToken?: EqualsToken; readonly objectAssignmentInitializer?: Expression; } export interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.SpreadAssignment; readonly parent: ObjectLiteralExpression; readonly expression: Expression; } export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag; export interface PropertyLikeDeclaration extends NamedDeclaration { readonly name: PropertyName; } export interface ObjectBindingPattern extends Node { readonly kind: SyntaxKind.ObjectBindingPattern; readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement; readonly elements: NodeArray<BindingElement>; } export interface ArrayBindingPattern extends Node { readonly kind: SyntaxKind.ArrayBindingPattern; readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement; readonly elements: NodeArray<ArrayBindingElement>; } export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern; export type ArrayBindingElement = BindingElement | OmittedExpression; /** * Several node kinds share function-like features such as a signature, * a name, and a body. These nodes should extend FunctionLikeDeclarationBase. * Examples: * - FunctionDeclaration * - MethodDeclaration * - AccessorDeclaration */ export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase { _functionLikeDeclarationBrand: any; readonly asteriskToken?: AsteriskToken; readonly questionToken?: QuestionToken; readonly exclamationToken?: ExclamationToken; readonly body?: Block | Expression; } export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction; /** @deprecated Use SignatureDeclaration */ export type FunctionLike = SignatureDeclaration; export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement { readonly kind: SyntaxKind.FunctionDeclaration; readonly name?: Identifier; readonly body?: FunctionBody; } export interface MethodSignature extends SignatureDeclarationBase, TypeElement { readonly kind: SyntaxKind.MethodSignature; readonly parent: ObjectTypeDeclaration; readonly name: PropertyName; } export interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.MethodDeclaration; readonly parent: ClassLikeDeclaration | ObjectLiteralExpression; readonly name: PropertyName; readonly body?: FunctionBody; } export interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer { readonly kind: SyntaxKind.Constructor; readonly parent: ClassLikeDeclaration; readonly body?: FunctionBody; } /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */ export interface SemicolonClassElement extends ClassElement { readonly kind: SyntaxKind.SemicolonClassElement; readonly parent: ClassLikeDeclaration; } export interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.GetAccessor; readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration; readonly name: PropertyName; readonly body?: FunctionBody; } export interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.SetAccessor; readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration; readonly name: PropertyName; readonly body?: FunctionBody; } export type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration; export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement { readonly kind: SyntaxKind.IndexSignature; readonly parent: ObjectTypeDeclaration; readonly type: TypeNode; } export interface TypeNode extends Node { _typeNodeBrand: any; } export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode { readonly kind: TKind; } export interface ImportTypeNode extends NodeWithTypeArguments { readonly kind: SyntaxKind.ImportType; readonly isTypeOf: boolean; readonly argument: TypeNode; readonly qualifier?: EntityName; } export interface ThisTypeNode extends TypeNode { readonly kind: SyntaxKind.ThisType; } export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode; export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase { readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType; readonly type: TypeNode; } export interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase { readonly kind: SyntaxKind.FunctionType; } export interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase { readonly kind: SyntaxKind.ConstructorType; } export interface NodeWithTypeArguments extends TypeNode { readonly typeArguments?: NodeArray<TypeNode>; } export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments; export interface TypeReferenceNode extends NodeWithTypeArguments { readonly kind: SyntaxKind.TypeReference; readonly typeName: EntityName; } export interface TypePredicateNode extends TypeNode { readonly kind: SyntaxKind.TypePredicate; readonly parent: SignatureDeclaration | JSDocTypeExpression; readonly assertsModifier?: AssertsToken; readonly parameterName: Identifier | ThisTypeNode; readonly type?: TypeNode; } export interface TypeQueryNode extends TypeNode { readonly kind: SyntaxKind.TypeQuery; readonly exprName: EntityName; } export interface TypeLiteralNode extends TypeNode, Declaration { readonly kind: SyntaxKind.TypeLiteral; readonly members: NodeArray<TypeElement>; } export interface ArrayTypeNode extends TypeNode { readonly kind: SyntaxKind.ArrayType; readonly elementType: TypeNode; } export interface TupleTypeNode extends TypeNode { readonly kind: SyntaxKind.TupleType; readonly elements: NodeArray<TypeNode | NamedTupleMember>; } export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration { readonly kind: SyntaxKind.NamedTupleMember; readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>; readonly name: Identifier; readonly questionToken?: Token<SyntaxKind.QuestionToken>; readonly type: TypeNode; } export interface OptionalTypeNode extends TypeNode { readonly kind: SyntaxKind.OptionalType; readonly type: TypeNode; } export interface RestTypeNode extends TypeNode { readonly kind: SyntaxKind.RestType; readonly type: TypeNode; } export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode; export interface UnionTypeNode extends TypeNode { readonly kind: SyntaxKind.UnionType; readonly types: NodeArray<TypeNode>; } export interface IntersectionTypeNode extends TypeNode { readonly kind: SyntaxKind.IntersectionType; readonly types: NodeArray<TypeNode>; } export interface ConditionalTypeNode extends TypeNode { readonly kind: SyntaxKind.ConditionalType; readonly checkType: TypeNode; readonly extendsType: TypeNode; readonly trueType: TypeNode; readonly falseType: TypeNode; } export interface InferTypeNode extends TypeNode { readonly kind: SyntaxKind.InferType; readonly typeParameter: TypeParameterDeclaration; } export interface ParenthesizedTypeNode extends TypeNode { readonly kind: SyntaxKind.ParenthesizedType; readonly type: TypeNode; } export interface TypeOperatorNode extends TypeNode { readonly kind: SyntaxKind.TypeOperator; readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword; readonly type: TypeNode; } export interface IndexedAccessTypeNode extends TypeNode { readonly kind: SyntaxKind.IndexedAccessType; readonly objectType: TypeNode; readonly indexType: TypeNode; } export interface MappedTypeNode extends TypeNode, Declaration { readonly kind: SyntaxKind.MappedType; readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken; readonly typeParameter: TypeParameterDeclaration; readonly nameType?: TypeNode; readonly questionToken?: QuestionToken | PlusToken | MinusToken; readonly type?: TypeNode; } export interface LiteralTypeNode extends TypeNode { readonly kind: SyntaxKind.LiteralType; readonly literal: NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression; } export interface StringLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.StringLiteral; } export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral; export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral; export interface TemplateLiteralTypeNode extends TypeNode { kind: SyntaxKind.TemplateLiteralType; readonly head: TemplateHead; readonly templateSpans: NodeArray<TemplateLiteralTypeSpan>; } export interface TemplateLiteralTypeSpan extends TypeNode { readonly kind: SyntaxKind.TemplateLiteralTypeSpan; readonly parent: TemplateLiteralTypeNode; readonly type: TypeNode; readonly literal: TemplateMiddle | TemplateTail; } export interface Expression extends Node { _expressionBrand: any; } export interface OmittedExpression extends Expression { readonly kind: SyntaxKind.OmittedExpression; } export interface PartiallyEmittedExpression extends LeftHandSideExpression { readonly kind: SyntaxKind.PartiallyEmittedExpression; readonly expression: Expression; } export interface UnaryExpression extends Expression { _unaryExpressionBrand: any; } /** Deprecated, please use UpdateExpression */ export type IncrementExpression = UpdateExpression; export interface UpdateExpression extends UnaryExpression { _updateExpressionBrand: any; } export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken; export interface PrefixUnaryExpression extends UpdateExpression { readonly kind: SyntaxKind.PrefixUnaryExpression; readonly operator: PrefixUnaryOperator; readonly operand: UnaryExpression; } export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken; export interface PostfixUnaryExpression extends UpdateExpression { readonly kind: SyntaxKind.PostfixUnaryExpression; readonly operand: LeftHandSideExpression; readonly operator: PostfixUnaryOperator; } export interface LeftHandSideExpression extends UpdateExpression { _leftHandSideExpressionBrand: any; } export interface MemberExpression extends LeftHandSideExpression { _memberExpressionBrand: any; } export interface PrimaryExpression extends MemberExpression { _primaryExpressionBrand: any; } export interface NullLiteral extends PrimaryExpression { readonly kind: SyntaxKind.NullKeyword; } export interface TrueLiteral extends PrimaryExpression { readonly kind: SyntaxKind.TrueKeyword; } export interface FalseLiteral extends PrimaryExpression { readonly kind: SyntaxKind.FalseKeyword; } export type BooleanLiteral = TrueLiteral | FalseLiteral; export interface ThisExpression extends PrimaryExpression { readonly kind: SyntaxKind.ThisKeyword; } export interface SuperExpression extends PrimaryExpression { readonly kind: SyntaxKind.SuperKeyword; } export interface ImportExpression extends PrimaryExpression { readonly kind: SyntaxKind.ImportKeyword; } export interface DeleteExpression extends UnaryExpression { readonly kind: SyntaxKind.DeleteExpression; readonly expression: UnaryExpression; } export interface TypeOfExpression extends UnaryExpression { readonly kind: SyntaxKind.TypeOfExpression; readonly expression: UnaryExpression; } export interface VoidExpression extends UnaryExpression { readonly kind: SyntaxKind.VoidExpression; readonly expression: UnaryExpression; } export interface AwaitExpression extends UnaryExpressi