awayjs-display

/*! ***************************************************************************** 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. ***************************************************************************** */ declare namespace ts { interface Map<T> { [index: string]: T; } type Path = string & { __pathBrand: any; }; interface FileMap<T> { get(fileName: Path): T; set(fileName: Path, value: T): void; contains(fileName: Path): boolean; remove(fileName: Path): void; forEachValue(f: (key: Path, v: T) => void): void; clear(): void; } interface TextRange { pos: number; end: number; } enum SyntaxKind { Unknown = 0, EndOfFileToken = 1, SingleLineCommentTrivia = 2, MultiLineCommentTrivia = 3, NewLineTrivia = 4, WhitespaceTrivia = 5, ShebangTrivia = 6, ConflictMarkerTrivia = 7, NumericLiteral = 8, StringLiteral = 9, RegularExpressionLiteral = 10, NoSubstitutionTemplateLiteral = 11, TemplateHead = 12, TemplateMiddle = 13, TemplateTail = 14, OpenBraceToken = 15, CloseBraceToken = 16, OpenParenToken = 17, CloseParenToken = 18, OpenBracketToken = 19, CloseBracketToken = 20, DotToken = 21, DotDotDotToken = 22, SemicolonToken = 23, CommaToken = 24, LessThanToken = 25, LessThanSlashToken = 26, GreaterThanToken = 27, LessThanEqualsToken = 28, GreaterThanEqualsToken = 29, EqualsEqualsToken = 30, ExclamationEqualsToken = 31, EqualsEqualsEqualsToken = 32, ExclamationEqualsEqualsToken = 33, EqualsGreaterThanToken = 34, PlusToken = 35, MinusToken = 36, AsteriskToken = 37, AsteriskAsteriskToken = 38, SlashToken = 39, PercentToken = 40, PlusPlusToken = 41, MinusMinusToken = 42, LessThanLessThanToken = 43, GreaterThanGreaterThanToken = 44, GreaterThanGreaterThanGreaterThanToken = 45, AmpersandToken = 46, BarToken = 47, CaretToken = 48, ExclamationToken = 49, TildeToken = 50, AmpersandAmpersandToken = 51, BarBarToken = 52, QuestionToken = 53, ColonToken = 54, AtToken = 55, EqualsToken = 56, PlusEqualsToken = 57, MinusEqualsToken = 58, AsteriskEqualsToken = 59, AsteriskAsteriskEqualsToken = 60, SlashEqualsToken = 61, PercentEqualsToken = 62, LessThanLessThanEqualsToken = 63, GreaterThanGreaterThanEqualsToken = 64, GreaterThanGreaterThanGreaterThanEqualsToken = 65, AmpersandEqualsToken = 66, BarEqualsToken = 67, CaretEqualsToken = 68, Identifier = 69, BreakKeyword = 70, CaseKeyword = 71, CatchKeyword = 72, ClassKeyword = 73, ConstKeyword = 74, ContinueKeyword = 75, DebuggerKeyword = 76, DefaultKeyword = 77, DeleteKeyword = 78, DoKeyword = 79, ElseKeyword = 80, EnumKeyword = 81, ExportKeyword = 82, ExtendsKeyword = 83, FalseKeyword = 84, FinallyKeyword = 85, ForKeyword = 86, FunctionKeyword = 87, IfKeyword = 88, ImportKeyword = 89, InKeyword = 90, InstanceOfKeyword = 91, NewKeyword = 92, NullKeyword = 93, ReturnKeyword = 94, SuperKeyword = 95, SwitchKeyword = 96, ThisKeyword = 97, ThrowKeyword = 98, TrueKeyword = 99, TryKeyword = 100, TypeOfKeyword = 101, VarKeyword = 102, VoidKeyword = 103, WhileKeyword = 104, WithKeyword = 105, ImplementsKeyword = 106, InterfaceKeyword = 107, LetKeyword = 108, PackageKeyword = 109, PrivateKeyword = 110, ProtectedKeyword = 111, PublicKeyword = 112, StaticKeyword = 113, YieldKeyword = 114, AbstractKeyword = 115, AsKeyword = 116, AnyKeyword = 117, AsyncKeyword = 118, AwaitKeyword = 119, BooleanKeyword = 120, ConstructorKeyword = 121, DeclareKeyword = 122, GetKeyword = 123, IsKeyword = 124, ModuleKeyword = 125, NamespaceKeyword = 126, RequireKeyword = 127, NumberKeyword = 128, SetKeyword = 129, StringKeyword = 130, SymbolKeyword = 131, TypeKeyword = 132, FromKeyword = 133, GlobalKeyword = 134, OfKeyword = 135, QualifiedName = 136, ComputedPropertyName = 137, TypeParameter = 138, Parameter = 139, Decorator = 140, PropertySignature = 141, PropertyDeclaration = 142, MethodSignature = 143, MethodDeclaration = 144, Constructor = 145, GetAccessor = 146, SetAccessor = 147, CallSignature = 148, ConstructSignature = 149, IndexSignature = 150, TypePredicate = 151, TypeReference = 152, FunctionType = 153, ConstructorType = 154, TypeQuery = 155, TypeLiteral = 156, ArrayType = 157, TupleType = 158, UnionType = 159, IntersectionType = 160, ParenthesizedType = 161, ThisType = 162, StringLiteralType = 163, ObjectBindingPattern = 164, ArrayBindingPattern = 165, BindingElement = 166, ArrayLiteralExpression = 167, ObjectLiteralExpression = 168, PropertyAccessExpression = 169, ElementAccessExpression = 170, CallExpression = 171, NewExpression = 172, TaggedTemplateExpression = 173, TypeAssertionExpression = 174, ParenthesizedExpression = 175, FunctionExpression = 176, ArrowFunction = 177, DeleteExpression = 178, TypeOfExpression = 179, VoidExpression = 180, AwaitExpression = 181, PrefixUnaryExpression = 182, PostfixUnaryExpression = 183, BinaryExpression = 184, ConditionalExpression = 185, TemplateExpression = 186, YieldExpression = 187, SpreadElementExpression = 188, ClassExpression = 189, OmittedExpression = 190, ExpressionWithTypeArguments = 191, AsExpression = 192, TemplateSpan = 193, SemicolonClassElement = 194, Block = 195, VariableStatement = 196, EmptyStatement = 197, ExpressionStatement = 198, IfStatement = 199, DoStatement = 200, WhileStatement = 201, ForStatement = 202, ForInStatement = 203, ForOfStatement = 204, ContinueStatement = 205, BreakStatement = 206, ReturnStatement = 207, WithStatement = 208, SwitchStatement = 209, LabeledStatement = 210, ThrowStatement = 211, TryStatement = 212, DebuggerStatement = 213, VariableDeclaration = 214, VariableDeclarationList = 215, FunctionDeclaration = 216, ClassDeclaration = 217, InterfaceDeclaration = 218, TypeAliasDeclaration = 219, EnumDeclaration = 220, ModuleDeclaration = 221, ModuleBlock = 222, CaseBlock = 223, ImportEqualsDeclaration = 224, ImportDeclaration = 225, ImportClause = 226, NamespaceImport = 227, NamedImports = 228, ImportSpecifier = 229, ExportAssignment = 230, ExportDeclaration = 231, NamedExports = 232, ExportSpecifier = 233, MissingDeclaration = 234, ExternalModuleReference = 235, JsxElement = 236, JsxSelfClosingElement = 237, JsxOpeningElement = 238, JsxText = 239, JsxClosingElement = 240, JsxAttribute = 241, JsxSpreadAttribute = 242, JsxExpression = 243, CaseClause = 244, DefaultClause = 245, HeritageClause = 246, CatchClause = 247, PropertyAssignment = 248, ShorthandPropertyAssignment = 249, EnumMember = 250, SourceFile = 251, JSDocTypeExpression = 252, JSDocAllType = 253, JSDocUnknownType = 254, JSDocArrayType = 255, JSDocUnionType = 256, JSDocTupleType = 257, JSDocNullableType = 258, JSDocNonNullableType = 259, JSDocRecordType = 260, JSDocRecordMember = 261, JSDocTypeReference = 262, JSDocOptionalType = 263, JSDocFunctionType = 264, JSDocVariadicType = 265, JSDocConstructorType = 266, JSDocThisType = 267, JSDocComment = 268, JSDocTag = 269, JSDocParameterTag = 270, JSDocReturnTag = 271, JSDocTypeTag = 272, JSDocTemplateTag = 273, SyntaxList = 274, Count = 275, FirstAssignment = 56, LastAssignment = 68, FirstReservedWord = 70, LastReservedWord = 105, FirstKeyword = 70, LastKeyword = 135, FirstFutureReservedWord = 106, LastFutureReservedWord = 114, FirstTypeNode = 151, LastTypeNode = 163, FirstPunctuation = 15, LastPunctuation = 68, FirstToken = 0, LastToken = 135, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, LastLiteralToken = 11, FirstTemplateToken = 11, LastTemplateToken = 14, FirstBinaryOperator = 25, LastBinaryOperator = 68, FirstNode = 136, } enum NodeFlags { None = 0, Export = 2, Ambient = 4, Public = 8, Private = 16, Protected = 32, Static = 64, Abstract = 128, Async = 256, Default = 512, MultiLine = 1024, Synthetic = 2048, DeclarationFile = 4096, Let = 8192, Const = 16384, OctalLiteral = 32768, Namespace = 65536, ExportContext = 131072, ContainsThis = 262144, HasImplicitReturn = 524288, HasExplicitReturn = 1048576, GlobalAugmentation = 2097152, HasClassExtends = 4194304, HasDecorators = 8388608, HasParamDecorators = 16777216, HasAsyncFunctions = 33554432, Modifier = 1022, AccessibilityModifier = 56, BlockScoped = 24576, ReachabilityCheckFlags = 1572864, EmitHelperFlags = 62914560, } 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, /** An element backed by a class, class-like, or function value */ ValueElement = 4, /** Element resolution failed */ UnknownElement = 16, IntrinsicElement = 3, } interface Node extends TextRange { kind: SyntaxKind; flags: NodeFlags; decorators?: NodeArray<Decorator>; modifiers?: ModifiersArray; parent?: Node; } interface NodeArray<T> extends Array<T>, TextRange { hasTrailingComma?: boolean; } interface ModifiersArray extends NodeArray<Modifier> { flags: number; } interface Modifier extends Node { } interface Identifier extends PrimaryExpression { text: string; originalKeywordKind?: SyntaxKind; } interface QualifiedName extends Node { left: EntityName; right: Identifier; } type EntityName = Identifier | QualifiedName; type PropertyName = Identifier | LiteralExpression | ComputedPropertyName; type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName | BindingPattern; interface Declaration extends Node { _declarationBrand: any; name?: DeclarationName; } interface DeclarationStatement extends Declaration, Statement { name?: Identifier; } interface ComputedPropertyName extends Node { expression: Expression; } interface Decorator extends Node { expression: LeftHandSideExpression; } interface TypeParameterDeclaration extends Declaration { name: Identifier; constraint?: TypeNode; expression?: Expression; } interface SignatureDeclaration extends Declaration { name?: PropertyName; typeParameters?: NodeArray<TypeParameterDeclaration>; parameters: NodeArray<ParameterDeclaration>; type?: TypeNode; } interface CallSignatureDeclaration extends SignatureDeclaration, TypeElement { } interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement { } interface VariableDeclaration extends Declaration { parent?: VariableDeclarationList; name: Identifier | BindingPattern; type?: TypeNode; initializer?: Expression; } interface VariableDeclarationList extends Node { declarations: NodeArray<VariableDeclaration>; } interface ParameterDeclaration extends Declaration { dotDotDotToken?: Node; name: Identifier | BindingPattern; questionToken?: Node; type?: TypeNode; initializer?: Expression; } interface BindingElement extends Declaration { propertyName?: PropertyName; dotDotDotToken?: Node; name: Identifier | BindingPattern; initializer?: Expression; } interface PropertySignature extends TypeElement { name: PropertyName; questionToken?: Node; type?: TypeNode; initializer?: Expression; } interface PropertyDeclaration extends ClassElement { questionToken?: Node; name: PropertyName; type?: TypeNode; initializer?: Expression; } interface ObjectLiteralElement extends Declaration { _objectLiteralBrandBrand: any; name?: PropertyName; } interface PropertyAssignment extends ObjectLiteralElement { _propertyAssignmentBrand: any; name: PropertyName; questionToken?: Node; initializer: Expression; } interface ShorthandPropertyAssignment extends ObjectLiteralElement { name: Identifier; questionToken?: Node; equalsToken?: Node; objectAssignmentInitializer?: Expression; } interface VariableLikeDeclaration extends Declaration { propertyName?: PropertyName; dotDotDotToken?: Node; name: DeclarationName; questionToken?: Node; type?: TypeNode; initializer?: Expression; } interface PropertyLikeDeclaration extends Declaration { name: PropertyName; } interface BindingPattern extends Node { elements: NodeArray<BindingElement>; } interface ObjectBindingPattern extends BindingPattern { } interface ArrayBindingPattern extends BindingPattern { } /** * Several node kinds share function-like features such as a signature, * a name, and a body. These nodes should extend FunctionLikeDeclaration. * Examples: * - FunctionDeclaration * - MethodDeclaration * - AccessorDeclaration */ interface FunctionLikeDeclaration extends SignatureDeclaration { _functionLikeDeclarationBrand: any; asteriskToken?: Node; questionToken?: Node; body?: Block | Expression; } interface FunctionDeclaration extends FunctionLikeDeclaration, DeclarationStatement { name?: Identifier; body?: FunctionBody; } interface MethodSignature extends SignatureDeclaration, TypeElement { name: PropertyName; } interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { name: PropertyName; body?: FunctionBody; } interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement { body?: FunctionBody; } interface SemicolonClassElement extends ClassElement { _semicolonClassElementBrand: any; } interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement { _accessorDeclarationBrand: any; name: PropertyName; body: FunctionBody; } interface GetAccessorDeclaration extends AccessorDeclaration { } interface SetAccessorDeclaration extends AccessorDeclaration { } interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement, TypeElement { _indexSignatureDeclarationBrand: any; } interface TypeNode extends Node { _typeNodeBrand: any; } interface ThisTypeNode extends TypeNode { _thisTypeNodeBrand: any; } interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration { _functionOrConstructorTypeNodeBrand: any; } interface FunctionTypeNode extends FunctionOrConstructorTypeNode { } interface ConstructorTypeNode extends FunctionOrConstructorTypeNode { } interface TypeReferenceNode extends TypeNode { typeName: EntityName; typeArguments?: NodeArray<TypeNode>; } interface TypePredicateNode extends TypeNode { parameterName: Identifier | ThisTypeNode; type: TypeNode; } interface TypeQueryNode extends TypeNode { exprName: EntityName; } interface TypeLiteralNode extends TypeNode, Declaration { members: NodeArray<TypeElement>; } interface ArrayTypeNode extends TypeNode { elementType: TypeNode; } interface TupleTypeNode extends TypeNode { elementTypes: NodeArray<TypeNode>; } interface UnionOrIntersectionTypeNode extends TypeNode { types: NodeArray<TypeNode>; } interface UnionTypeNode extends UnionOrIntersectionTypeNode { } interface IntersectionTypeNode extends UnionOrIntersectionTypeNode { } interface ParenthesizedTypeNode extends TypeNode { type: TypeNode; } interface StringLiteralTypeNode extends LiteralLikeNode, TypeNode { _stringLiteralTypeBrand: any; } interface StringLiteral extends LiteralExpression { _stringLiteralBrand: any; } interface Expression extends Node { _expressionBrand: any; contextualType?: Type; } interface OmittedExpression extends Expression { } interface UnaryExpression extends Expression { _unaryExpressionBrand: any; } interface IncrementExpression extends UnaryExpression { _incrementExpressionBrand: any; } interface PrefixUnaryExpression extends IncrementExpression { operator: SyntaxKind; operand: UnaryExpression; } interface PostfixUnaryExpression extends IncrementExpression { operand: LeftHandSideExpression; operator: SyntaxKind; } interface PostfixExpression extends UnaryExpression { _postfixExpressionBrand: any; } interface LeftHandSideExpression extends IncrementExpression { _leftHandSideExpressionBrand: any; } interface MemberExpression extends LeftHandSideExpression { _memberExpressionBrand: any; } interface PrimaryExpression extends MemberExpression { _primaryExpressionBrand: any; } interface DeleteExpression extends UnaryExpression { expression: UnaryExpression; } interface TypeOfExpression extends UnaryExpression { expression: UnaryExpression; } interface VoidExpression extends UnaryExpression { expression: UnaryExpression; } interface AwaitExpression extends UnaryExpression { expression: UnaryExpression; } interface YieldExpression extends Expression { asteriskToken?: Node; expression?: Expression; } interface BinaryExpression extends Expression, Declaration { left: Expression; operatorToken: Node; right: Expression; } interface ConditionalExpression extends Expression { condition: Expression; questionToken: Node; whenTrue: Expression; colonToken: Node; whenFalse: Expression; } type FunctionBody = Block; type ConciseBody = FunctionBody | Expression; interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration { name?: Identifier; body: FunctionBody; } interface ArrowFunction extends Expression, FunctionLikeDeclaration { equalsGreaterThanToken: Node; body: ConciseBody; } interface LiteralLikeNode extends Node { text: string; isUnterminated?: boolean; hasExtendedUnicodeEscape?: boolean; } interface LiteralExpression extends LiteralLikeNode, PrimaryExpression { _literalExpressionBrand: any; } interface TemplateLiteralFragment extends LiteralLikeNode { _templateLiteralFragmentBrand: any; } interface TemplateExpression extends PrimaryExpression { head: TemplateLiteralFragment; templateSpans: NodeArray<TemplateSpan>; } interface TemplateSpan extends Node { expression: Expression; literal: TemplateLiteralFragment; } interface ParenthesizedExpression extends PrimaryExpression { expression: Expression; } interface ArrayLiteralExpression extends PrimaryExpression { elements: NodeArray<Expression>; } interface SpreadElementExpression extends Expression { expression: Expression; } interface ObjectLiteralExpression extends PrimaryExpression, Declaration { properties: NodeArray<ObjectLiteralElement>; } interface PropertyAccessExpression extends MemberExpression, Declaration { expression: LeftHandSideExpression; dotToken: Node; name: Identifier; } interface ElementAccessExpression extends MemberExpression { expression: LeftHandSideExpression; argumentExpression?: Expression; } interface CallExpression extends LeftHandSideExpression, Declaration { expression: LeftHandSideExpression; typeArguments?: NodeArray<TypeNode>; arguments: NodeArray<Expression>; } interface ExpressionWithTypeArguments extends TypeNode { expression: LeftHandSideExpression; typeArguments?: NodeArray<TypeNode>; } interface NewExpression extends CallExpression, PrimaryExpression { } interface TaggedTemplateExpression extends MemberExpression { tag: LeftHandSideExpression; template: LiteralExpression | TemplateExpression; } type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator; interface AsExpression extends Expression { expression: Expression; type: TypeNode; } interface TypeAssertion extends UnaryExpression { type: TypeNode; expression: UnaryExpression; } type AssertionExpression = TypeAssertion | AsExpression; interface JsxElement extends PrimaryExpression { openingElement: JsxOpeningElement; children: NodeArray<JsxChild>; closingElement: JsxClosingElement; } interface JsxOpeningElement extends Expression { _openingElementBrand?: any; tagName: EntityName; attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>; } interface JsxSelfClosingElement extends PrimaryExpression, JsxOpeningElement { _selfClosingElementBrand?: any; } type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement; interface JsxAttribute extends Node { name: Identifier; initializer?: Expression; } interface JsxSpreadAttribute extends Node { expression: Expression; } interface JsxClosingElement extends Node { tagName: EntityName; } interface JsxExpression extends Expression { expression?: Expression; } interface JsxText extends Node { _jsxTextExpressionBrand: any; } type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement; interface Statement extends Node { _statementBrand: any; } interface EmptyStatement extends Statement { } interface DebuggerStatement extends Statement { } interface MissingDeclaration extends DeclarationStatement, ClassElement, ObjectLiteralElement, TypeElement { name?: Identifier; } type BlockLike = SourceFile | Block | ModuleBlock | CaseClause; interface Block extends Statement { statements: NodeArray<Statement>; } interface VariableStatement extends Statement { declarationList: VariableDeclarationList; } interface ExpressionStatement extends Statement { expression: Expression; } interface IfStatement extends Statement { expression: Expression; thenStatement: Statement; elseStatement?: Statement; } interface IterationStatement extends Statement { statement: Statement; } interface DoStatement extends IterationStatement { expression: Expression; } interface WhileStatement extends IterationStatement { expression: Expression; } interface ForStatement extends IterationStatement { initializer?: VariableDeclarationList | Expression; condition?: Expression; incrementor?: Expression; } interface ForInStatement extends IterationStatement { initializer: VariableDeclarationList | Expression; expression: Expression; } interface ForOfStatement extends IterationStatement { initializer: VariableDeclarationList | Expression; expression: Expression; } interface BreakStatement extends Statement { label?: Identifier; } interface ContinueStatement extends Statement { label?: Identifier; } type BreakOrContinueStatement = BreakStatement | ContinueStatement; interface ReturnStatement extends Statement { expression?: Expression; } interface WithStatement extends Statement { expression: Expression; statement: Statement; } interface SwitchStatement extends Statement { expression: Expression; caseBlock: CaseBlock; } interface CaseBlock extends Node { clauses: NodeArray<CaseOrDefaultClause>; } interface CaseClause extends Node { expression: Expression; statements: NodeArray<Statement>; } interface DefaultClause extends Node { statements: NodeArray<Statement>; } type CaseOrDefaultClause = CaseClause | DefaultClause; interface LabeledStatement extends Statement { label: Identifier; statement: Statement; } interface ThrowStatement extends Statement { expression: Expression; } interface TryStatement extends Statement { tryBlock: Block; catchClause?: CatchClause; finallyBlock?: Block; } interface CatchClause extends Node { variableDeclaration: VariableDeclaration; block: Block; } interface ClassLikeDeclaration extends Declaration { name?: Identifier; typeParameters?: NodeArray<TypeParameterDeclaration>; heritageClauses?: NodeArray<HeritageClause>; members: NodeArray<ClassElement>; } interface ClassDeclaration extends ClassLikeDeclaration, DeclarationStatement { name?: Identifier; } interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression { } interface ClassElement extends Declaration { _classElementBrand: any; name?: PropertyName; } interface TypeElement extends Declaration { _typeElementBrand: any; name?: PropertyName; questionToken?: Node; } interface InterfaceDeclaration extends DeclarationStatement { name: Identifier; typeParameters?: NodeArray<TypeParameterDeclaration>; heritageClauses?: NodeArray<HeritageClause>; members: NodeArray<TypeElement>; } interface HeritageClause extends Node { token: SyntaxKind; types?: NodeArray<ExpressionWithTypeArguments>; } interface TypeAliasDeclaration extends DeclarationStatement { name: Identifier; typeParameters?: NodeArray<TypeParameterDeclaration>; type: TypeNode; } interface EnumMember extends Declaration { name: DeclarationName; initializer?: Expression; } interface EnumDeclaration extends DeclarationStatement { name: Identifier; members: NodeArray<EnumMember>; } type ModuleBody = ModuleBlock | ModuleDeclaration; interface ModuleDeclaration extends DeclarationStatement { name: Identifier | LiteralExpression; body: ModuleBlock | ModuleDeclaration; } interface ModuleBlock extends Node, Statement { statements: NodeArray<Statement>; } interface ImportEqualsDeclaration extends DeclarationStatement { name: Identifier; moduleReference: EntityName | ExternalModuleReference; } interface ExternalModuleReference extends Node { expression?: Expression; } interface ImportDeclaration extends Statement { importClause?: ImportClause; moduleSpecifier: Expression; } interface ImportClause extends Declaration { name?: Identifier; namedBindings?: NamespaceImport | NamedImports; } interface NamespaceImport extends Declaration { name: Identifier; } interface ExportDeclaration extends DeclarationStatement { exportClause?: NamedExports; moduleSpecifier?: Expression; } interface NamedImports extends Node { elements: NodeArray<ImportSpecifier>; } interface NamedExports extends Node { elements: NodeArray<ExportSpecifier>; } type NamedImportsOrExports = NamedImports | NamedExports; interface ImportSpecifier extends Declaration { propertyName?: Identifier; name: Identifier; } interface ExportSpecifier extends Declaration { propertyName?: Identifier; name: Identifier; } type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier; interface ExportAssignment extends DeclarationStatement { isExportEquals?: boolean; expression: Expression; } interface FileReference extends TextRange { fileName: string; } interface CommentRange extends TextRange { hasTrailingNewLine?: boolean; kind: SyntaxKind; } interface JSDocTypeExpression extends Node { type: JSDocType; } interface JSDocType extends TypeNode { _jsDocTypeBrand: any; } interface JSDocAllType extends JSDocType { _JSDocAllTypeBrand: any; } interface JSDocUnknownType extends JSDocType { _JSDocUnknownTypeBrand: any; } interface JSDocArrayType extends JSDocType { elementType: JSDocType; } interface JSDocUnionType extends JSDocType { types: NodeArray<JSDocType>; } interface JSDocTupleType extends JSDocType { types: NodeArray<JSDocType>; } interface JSDocNonNullableType extends JSDocType { type: JSDocType; } interface JSDocNullableType extends JSDocType { type: JSDocType; } interface JSDocRecordType extends JSDocType, TypeLiteralNode { members: NodeArray<JSDocRecordMember>; } interface JSDocTypeReference extends JSDocType { name: EntityName; typeArguments: NodeArray<JSDocType>; } interface JSDocOptionalType extends JSDocType { type: JSDocType; } interface JSDocFunctionType extends JSDocType, SignatureDeclaration { parameters: NodeArray<ParameterDeclaration>; type: JSDocType; } interface JSDocVariadicType extends JSDocType { type: JSDocType; } interface JSDocConstructorType extends JSDocType { type: JSDocType; } interface JSDocThisType extends JSDocType { type: JSDocType; } type JSDocTypeReferencingNode = JSDocThisType | JSDocConstructorType | JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType; interface JSDocRecordMember extends PropertySignature { name: Identifier | LiteralExpression; type?: JSDocType; } interface JSDocComment extends Node { tags: NodeArray<JSDocTag>; } interface JSDocTag extends Node { atToken: Node; tagName: Identifier; } interface JSDocTemplateTag extends JSDocTag { typeParameters: NodeArray<TypeParameterDeclaration>; } interface JSDocReturnTag extends JSDocTag { typeExpression: JSDocTypeExpression; } interface JSDocTypeTag extends JSDocTag { typeExpression: JSDocTypeExpression; } interface JSDocParameterTag extends JSDocTag { preParameterName?: Identifier; typeExpression?: JSDocTypeExpression; postParameterName?: Identifier; isBracketed: boolean; } interface AmdDependency { path: string; name: string; } interface SourceFile extends Declaration { statements: NodeArray<Statement>; endOfFileToken: Node; fileName: string; path: Path; text: string; amdDependencies: AmdDependency[]; moduleName: string; referencedFiles: FileReference[]; languageVariant: LanguageVariant; /** * lib.d.ts should have a reference comment like * * /// <reference no-default-lib="true"/> * * If any other file has this comment, it signals not to include lib.d.ts * because this containing file is intended to act as a default library. */ hasNoDefaultLib: boolean; languageVersion: ScriptTarget; } interface ScriptReferenceHost { getCompilerOptions(): CompilerOptions; getSourceFile(fileName: string): SourceFile; getCurrentDirectory(): string; } interface ParseConfigHost { readDirectory(rootDir: string, extension: string, exclude: string[]): string[]; } interface WriteFileCallback { (fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void; } class OperationCanceledException { } interface CancellationToken { isCancellationRequested(): boolean; /** @throws OperationCanceledException if isCancellationRequested is true */ throwIfCancellationRequested(): void; } interface Program extends ScriptReferenceHost { /** * Get a list of root file names that were passed to a 'createProgram' */ getRootFileNames(): string[]; /** * Get a list of files in the program */ getSourceFiles(): SourceFile[]; /** * Emits the JavaScript and declaration files. If targetSourceFile is not specified, then * the JavaScript and declaration files will be produced for all the files in this program. * If targetSourceFile is specified, then only the JavaScript and declaration for that * specific file will be generated. * * If writeFile is not specified then the writeFile callback from the compiler host will be * used for writing the JavaScript and declaration files. Otherwise, the writeFile parameter * will be invoked when writing the JavaScript and declaration files. */ emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult; getOptionsDiagnostics(cancellationToken?: CancellationToken): Diagnostic[]; getGlobalDiagnostics(cancellationToken?: CancellationToken): Diagnostic[]; getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; /** * Gets a type checker that can be used to semantically analyze source fils in the program. */ getTypeChecker(): TypeChecker; } interface SourceMapSpan { /** Line number in the .js file. */ emittedLine: number; /** Column number in the .js file. */ emittedColumn: number; /** Line number in the .ts file. */ sourceLine: number; /** Column number in the .ts file. */ sourceColumn: number; /** Optional name (index into names array) associated with this span. */ nameIndex?: number; /** .ts file (index into sources array) associated with this span */ sourceIndex: number; } interface SourceMapData { sourceMapFilePath: string; jsSourceMappingURL: string; sourceMapFile: string; sourceMapSourceRoot: string; sourceMapSources: string[]; sourceMapSourcesContent?: string[]; inputSourceFileNames: string[]; sourceMapNames?: string[]; sourceMapMappings: string; sourceMapDecodedMappings: SourceMapSpan[]; } /** Return code used by getEmitOutput function to indicate status of the function */ enum ExitStatus { Success = 0, DiagnosticsPresent_OutputsSkipped = 1, DiagnosticsPresent_OutputsGenerated = 2, } interface EmitResult { emitSkipped: boolean; diagnostics: Diagnostic[]; } interface TypeChecker { getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; getDeclaredTypeOfSymbol(symbol: Symbol): Type; getPropertiesOfType(type: Type): Symbol[]; getPropertyOfType(type: Type, propertyName: string): Symbol; getSignaturesOfType(type: Type, kind: SignatureKind): Signature[]; getIndexTypeOfType(type: Type, kind: IndexKind): Type; getBaseTypes(type: InterfaceType): ObjectType[]; getReturnTypeOfSignature(signature: Signature): Type; getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; getSymbolAtLocation(node: Node): Symbol; getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[]; getShorthandAssignmentValueSymbol(location: Node): Symbol; getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol; getTypeAtLocation(node: Node): Type; typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; getSymbolDisplayBuilder(): SymbolDisplayBuilder; getFullyQualifiedName(symbol: Symbol): string; getAugmentedPropertiesOfType(type: Type): Symbol[]; getRootSymbols(symbol: Symbol): Symbol[]; getContextualType(node: Expression): Type; getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature; getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature; isImplementationOfOverload(node: FunctionLikeDeclaration): boolean; isUndefinedSymbol(symbol: Symbol): boolean; isArgumentsSymbol(symbol: Symbol): boolean; isUnknownSymbol(symbol: Symbol): boolean; getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number; isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; getAliasedSymbol(symbol: Symbol): Symbol; getExportsOfModule(moduleSymbol: Symbol): Symbol[]; getJsxElementAttributesType(elementNode: JsxOpeningLikeElement): Type; getJsxIntrinsicTagNames(): Symbol[]; isOptionalParameter(node: ParameterDeclaration): boolean; } interface SymbolDisplayBuilder { buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): void; buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildTypePredicateDisplay(predicate: TypePredicate, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; } interface SymbolWriter { writeKeyword(text: string): void; writeOperator(text: string): void; writePunctuation(text: string): void; writeSpace(text: string): void; writeStringLiteral(text: string): void; writeParameter(text: string): void; writeSymbol(text: string, symbol: Symbol): void; writeLine(): void; increaseIndent(): void; decreaseIndent(): void; clear(): void; trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; reportInaccessibleThisError(): void; } enum TypeFormatFlags { None = 0, WriteArrayAsGenericType = 1, UseTypeOfFunction = 2, NoTruncation = 4, WriteArrowStyleSignature = 8, WriteOwnNameForAnyLike = 16, WriteTypeArgumentsOfSignature = 32, InElementType = 64, UseFullyQualifiedType = 128, } enum SymbolFormatFlags { None = 0, WriteTypeParametersOrArguments = 1, UseOnlyExternalAliasing = 2, } enum TypePredicateKind { This = 0, Identifier = 1, } interface TypePredicateBase { kind: TypePredicateKind; type: Type; } interface ThisTypePredicate extends TypePredicateBase { _thisTypePredicateBrand: any; } interface IdentifierTypePredicate extends TypePredicateBase { parameterName: string; parameterIndex: number; } type TypePredicate = IdentifierTypePredicate | ThisTypePredicate; enum SymbolFlags { None = 0, FunctionScopedVariable = 1, BlockScopedVariable = 2, Property = 4, EnumMember = 8, Function = 16, Class = 32, Interface = 64, ConstEnum = 128, RegularEnum = 256, ValueModule = 512, NamespaceModule = 1024, TypeLiteral = 2048, ObjectLiteral = 4096, Method = 8192, Constructor = 16384, GetAccessor = 32768, SetAccessor = 65536, Signature = 131072, TypeParameter = 262144, TypeAlias = 524288, ExportValue = 1048576, ExportType = 2097152, ExportNamespace = 4194304, Alias = 8388608, Instantiated = 16777216, Merged = 33554432, Transient = 67108864, Prototype = 134217728, SyntheticProperty = 268435456, Optional = 536870912, ExportStar = 1073741824, Enum = 384, Variable = 3, Value = 107455, Type = 793056, Namespace = 1536, Module = 1536, Accessor = 98304, FunctionScopedVariableExcludes = 107454, BlockScopedVariableExcludes = 107455, ParameterExcludes = 107455, PropertyExcludes = 107455, EnumMemberExcludes = 107455, FunctionExcludes = 106927, ClassExcludes = 899519, InterfaceExcludes = 792960, RegularEnumExcludes = 899327, ConstEnumExcludes = 899967, ValueModuleExcludes = 106639, NamespaceModuleExcludes = 0, MethodExcludes = 99263, GetAccessorExcludes = 41919, SetAccessorExcludes = 74687, TypeParameterExcludes = 530912, TypeAliasExcludes = 793056, AliasExcludes = 8388608, ModuleMember = 8914931, ExportHasLocal = 944, HasExports = 1952, HasMembers = 6240, BlockScoped = 418, PropertyOrAccessor = 98308, Export = 7340032, } interface Symbol { flags: SymbolFlags; name: string; declarations?: Declaration[]; valueDeclaration?: Declaration; members?: SymbolTable; exports?: SymbolTable; } interface SymbolTable { [index: string]: Symbol; } enum TypeFlags { Any = 1, String = 2, Number = 4, Boolean = 8, Void = 16, Undefined = 32, Null = 64, Enum = 128, StringLiteral = 256, TypeParameter = 512, Class = 1024, Interface = 2048, Reference = 4096, Tuple = 8192, Union = 16384, Intersection = 32768, Anonymous = 65536, Instantiated = 131072, ObjectLiteral = 524288, ESSymbol = 16777216, ThisType = 33554432, ObjectLiteralPatternWithComputedProperties = 67108864, StringLike = 258, NumberLike = 132, ObjectType = 80896, UnionOrIntersection = 49152, StructuredType = 130048, } type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression; interface Type { flags: TypeFlags; symbol?: Symbol; pattern?: DestructuringPattern; } interface StringLiteralType extends Type { text: string; } interface ObjectType extends Type { } interface InterfaceType extends ObjectType { typeParameters: TypeParameter[]; outerTypeParameters: TypeParameter[]; localTypeParameters: TypeParameter[]; thisType: TypeParameter; } interface InterfaceTypeWithDeclaredMembers extends InterfaceType { declaredProperties: Symbol[]; declaredCallSignatures: Signature[]; declaredConstructSignatures: Signature[]; declaredStringIndexType: Type; declaredNumberIndexType: Type; } interface TypeReference extends ObjectType { target: GenericType; typeArguments: Type[]; } interface GenericType extends InterfaceType, TypeReference { } interface TupleType extends ObjectType { elementTypes: Type[]; } interface UnionOrIntersectionType extends Type { types: Type[]; } interface UnionType extends UnionOrIntersectionType { } interface IntersectionType extends UnionOrIntersectionType { } interface TypeParameter extends Type { constraint: Type; } enum SignatureKind { Call = 0, Construct = 1, } interface Signature { declaration: SignatureDeclaration; typeParameters: TypeParameter[]; parameters: Symbol[]; } enum IndexKind { String = 0, Number = 1, } interface DiagnosticMessage { key: string; category: DiagnosticCategory; code: number; message: string; } /** * A linked list of formatted diagnostic messages to be used as part of a multiline message. * It is built from the bottom up, leaving the head to be the "main" diagnostic. * While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage, * the difference is that messages are all preformatted in DMC. */ interface DiagnosticMessageChain { messageText: string; category: DiagnosticCategory; code: number; next?: DiagnosticMessageChain; } interface Diagnostic { file: SourceFile; start: number; length: number; messageText: string | DiagnosticMessageChain; category: DiagnosticCategory; code: number; } enum DiagnosticCategory { Warning = 0, Error = 1, Message = 2, } enum ModuleResolutionKind { Classic = 1, NodeJs = 2, } interface CompilerOptions { allowNo