5046 lines
119 KiB
Plaintext
5046 lines
119 KiB
Plaintext
/**
|
|
* @flow
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/*
|
|
* Flow types for the Babylon AST.
|
|
*/
|
|
|
|
// Abstract types. Something must extend these.
|
|
|
|
export type Comment = {
|
|
type: 'CommentLine',
|
|
_CommentLine?: void,
|
|
value: string,
|
|
end: number,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
} | {
|
|
type: 'CommentBlock',
|
|
_CommentBlock?: void,
|
|
value: string,
|
|
end: number,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
};
|
|
|
|
export type Declaration = {
|
|
type: 'ClassBody',
|
|
_ClassBody?: void,
|
|
body: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassDeclaration',
|
|
_ClassDeclaration?: void,
|
|
body: ClassBody,
|
|
id: ?Identifier,
|
|
superClass: ?Expression,
|
|
decorators: any,
|
|
superTypeParameters: any,
|
|
typeParameters: any,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'FunctionDeclaration',
|
|
_FunctionDeclaration?: void,
|
|
body: BlockStatement,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'MethodDefinition',
|
|
_MethodDefinition?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
kind: 'constructor' | 'method' | 'get' | 'set',
|
|
static: boolean,
|
|
value: FunctionExpression,
|
|
decorators: ?Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'VariableDeclaration',
|
|
_VariableDeclaration?: void,
|
|
declarations: Array<VariableDeclarator>,
|
|
kind: 'var' | 'let' | 'const',
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassProperty',
|
|
_ClassProperty?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
static: boolean,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
value: ?Expression,
|
|
decorators: Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Expression = {
|
|
type: 'ArrayExpression',
|
|
_ArrayExpression?: void,
|
|
elements: Array<?Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'AssignmentExpression',
|
|
_AssignmentExpression?: void,
|
|
left: Pattern,
|
|
operator: AssignmentOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'AwaitExpression',
|
|
_AwaitExpression?: void,
|
|
all: boolean,
|
|
argument: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BinaryExpression',
|
|
_BinaryExpression?: void,
|
|
left: Expression,
|
|
operator: BinaryOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BindExpression',
|
|
_BindExpression?: void,
|
|
callee: Node,
|
|
object: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'CallExpression',
|
|
_CallExpression?: void,
|
|
arguments: Array<Node>,
|
|
callee: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassExpression',
|
|
_ClassExpression?: void,
|
|
body: ClassBody,
|
|
id: ?Identifier,
|
|
superClass: ?Expression,
|
|
decorators: any,
|
|
superTypeParameters: any,
|
|
typeParameters: any,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ComprehensionExpression',
|
|
_ComprehensionExpression?: void,
|
|
body: Expression,
|
|
blocks: Array<ComprehensionBlock>,
|
|
filter: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ConditionalExpression',
|
|
_ConditionalExpression?: void,
|
|
alternate: Expression,
|
|
consequent: Expression,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DoExpression',
|
|
_DoExpression?: void,
|
|
body: Statement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'FunctionExpression',
|
|
_FunctionExpression?: void,
|
|
body: BlockStatement,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'Identifier',
|
|
_Identifier?: void,
|
|
name: string,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Literal',
|
|
_Literal?: void,
|
|
raw: string,
|
|
regex: ?{pattern: string, flags: string},
|
|
value: ?(string | boolean | number | RegExp),
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'LogicalExpression',
|
|
_LogicalExpression?: void,
|
|
left: Expression,
|
|
operator: LogicalOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'MemberExpression',
|
|
_MemberExpression?: void,
|
|
computed: boolean,
|
|
object: Expression,
|
|
property: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NewExpression',
|
|
_NewExpression?: void,
|
|
arguments: Array<Node>,
|
|
callee: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectExpression',
|
|
_ObjectExpression?: void,
|
|
properties: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SequenceExpression',
|
|
_SequenceExpression?: void,
|
|
expression: Array<Expression>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TaggedTemplateExpression',
|
|
_TaggedTemplateExpression?: void,
|
|
quasi: TemplateLiteral,
|
|
tag: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TemplateLiteral',
|
|
_TemplateLiteral?: void,
|
|
expressions: Array<Expression>,
|
|
quasis: Array<TemplateElement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ThisExpression',
|
|
_ThisExpression?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'UnaryExpression',
|
|
_UnaryExpression?: void,
|
|
argument: Expression,
|
|
operator: UnaryOperator,
|
|
prefix: true,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'UpdateExpression',
|
|
_UpdateExpression?: void,
|
|
argument: Expression,
|
|
operator: UpdateOperator,
|
|
prefix: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'YieldExpression',
|
|
_YieldExpression?: void,
|
|
argument: ?Expression,
|
|
delegate: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeCastExpression',
|
|
_TypeCastExpression?: void,
|
|
expression: Expression,
|
|
typeAnnotation: TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXElement',
|
|
_JSXElement?: void,
|
|
children: Array<Node>,
|
|
closingElement: ?JSXClosingElement,
|
|
openingElement: JSXOpeningElement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXEmptyExpression',
|
|
_JSXEmptyExpression?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXExpressionContainer',
|
|
_JSXExpressionContainer?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXMemberExpression',
|
|
_JSXMemberExpression?: void,
|
|
computed: boolean,
|
|
object: Node,
|
|
property: JSXIdentifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Function = {
|
|
type: 'ArrowFunctionExpression',
|
|
_ArrowFunctionExpression?: void,
|
|
body: Node,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'FunctionDeclaration',
|
|
_FunctionDeclaration?: void,
|
|
body: BlockStatement,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'FunctionExpression',
|
|
_FunctionExpression?: void,
|
|
body: BlockStatement,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
};
|
|
|
|
export type Node = {
|
|
type: 'ArrayExpression',
|
|
_ArrayExpression?: void,
|
|
elements: Array<?Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ArrayPattern',
|
|
_ArrayPattern?: void,
|
|
elements: Array<?Node>,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ArrowFunctionExpression',
|
|
_ArrowFunctionExpression?: void,
|
|
body: Node,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'AssignmentExpression',
|
|
_AssignmentExpression?: void,
|
|
left: Pattern,
|
|
operator: AssignmentOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'AssignmentPattern',
|
|
_AssignmentPattern?: void,
|
|
left: Pattern,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'AwaitExpression',
|
|
_AwaitExpression?: void,
|
|
all: boolean,
|
|
argument: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BinaryExpression',
|
|
_BinaryExpression?: void,
|
|
left: Expression,
|
|
operator: BinaryOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BindExpression',
|
|
_BindExpression?: void,
|
|
callee: Node,
|
|
object: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BlockStatement',
|
|
_BlockStatement?: void,
|
|
body: Array<Statement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BreakStatement',
|
|
_BreakStatement?: void,
|
|
label: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'CallExpression',
|
|
_CallExpression?: void,
|
|
arguments: Array<Node>,
|
|
callee: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'CatchClause',
|
|
_CatchClause?: void,
|
|
body: BlockStatement,
|
|
param: Pattern,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassBody',
|
|
_ClassBody?: void,
|
|
body: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassDeclaration',
|
|
_ClassDeclaration?: void,
|
|
body: ClassBody,
|
|
id: ?Identifier,
|
|
superClass: ?Expression,
|
|
decorators: any,
|
|
superTypeParameters: any,
|
|
typeParameters: any,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassExpression',
|
|
_ClassExpression?: void,
|
|
body: ClassBody,
|
|
id: ?Identifier,
|
|
superClass: ?Expression,
|
|
decorators: any,
|
|
superTypeParameters: any,
|
|
typeParameters: any,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ComprehensionBlock',
|
|
_ComprehensionBlock?: void,
|
|
each: boolean,
|
|
left: Pattern,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ComprehensionExpression',
|
|
_ComprehensionExpression?: void,
|
|
body: Expression,
|
|
blocks: Array<ComprehensionBlock>,
|
|
filter: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ConditionalExpression',
|
|
_ConditionalExpression?: void,
|
|
alternate: Expression,
|
|
consequent: Expression,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ContinueStatement',
|
|
_ContinueStatement?: void,
|
|
label: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Decorator',
|
|
_Decorator?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DebuggerStatement',
|
|
_DebuggerStatement?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DoWhileStatement',
|
|
_DoWhileStatement?: void,
|
|
body: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DoExpression',
|
|
_DoExpression?: void,
|
|
body: Statement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'EmptyStatement',
|
|
_EmptyStatement?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExpressionStatement',
|
|
_ExpressionStatement?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'File',
|
|
_File?: void,
|
|
program: Program,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ForInStatement',
|
|
_ForInStatement?: void,
|
|
body: Statement,
|
|
left: Node,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ForOfStatement',
|
|
_ForOfStatement?: void,
|
|
body: Statement,
|
|
left: Node,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ForStatement',
|
|
_ForStatement?: void,
|
|
init: ?Node,
|
|
test: ?Expression,
|
|
update: ?Expression,
|
|
body: Statement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'FunctionDeclaration',
|
|
_FunctionDeclaration?: void,
|
|
body: BlockStatement,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'FunctionExpression',
|
|
_FunctionExpression?: void,
|
|
body: BlockStatement,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
} | {
|
|
type: 'Identifier',
|
|
_Identifier?: void,
|
|
name: string,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'IfStatement',
|
|
_IfStatement?: void,
|
|
alternate: ?Statement,
|
|
consequent: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ImportDefaultSpecifier',
|
|
_ImportDefaultSpecifier?: void,
|
|
local: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ImportNamespaceSpecifier',
|
|
_ImportNamespaceSpecifier?: void,
|
|
local: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ImportDeclaration',
|
|
_ImportDeclaration?: void,
|
|
specifiers: Array<Node>,
|
|
source: Literal,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ImportSpecifier',
|
|
_ImportSpecifier?: void,
|
|
imported: Node,
|
|
local: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'LabeledStatement',
|
|
_LabeledStatement?: void,
|
|
body: Statement,
|
|
label: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Literal',
|
|
_Literal?: void,
|
|
raw: string,
|
|
regex: ?{pattern: string, flags: string},
|
|
value: ?(string | boolean | number | RegExp),
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'LogicalExpression',
|
|
_LogicalExpression?: void,
|
|
left: Expression,
|
|
operator: LogicalOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'MemberExpression',
|
|
_MemberExpression?: void,
|
|
computed: boolean,
|
|
object: Expression,
|
|
property: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'MetaProperty',
|
|
_MetaProperty?: void,
|
|
meta: Node,
|
|
property: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'MethodDefinition',
|
|
_MethodDefinition?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
kind: 'constructor' | 'method' | 'get' | 'set',
|
|
static: boolean,
|
|
value: FunctionExpression,
|
|
decorators: ?Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NewExpression',
|
|
_NewExpression?: void,
|
|
arguments: Array<Node>,
|
|
callee: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Noop',
|
|
_Noop?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectExpression',
|
|
_ObjectExpression?: void,
|
|
properties: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectPattern',
|
|
_ObjectPattern?: void,
|
|
properties: Array<Node>,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Program',
|
|
_Program?: void,
|
|
body: Array<Statement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Property',
|
|
_Property?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
kind: 'init' | 'get' | 'set',
|
|
method: boolean,
|
|
shorthand: boolean,
|
|
value: Node,
|
|
decorators: ?Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'RestElement',
|
|
_RestElement?: void,
|
|
argument: Pattern,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ReturnStatement',
|
|
_ReturnStatement?: void,
|
|
argument: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SequenceExpression',
|
|
_SequenceExpression?: void,
|
|
expression: Array<Expression>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SpreadElement',
|
|
_SpreadElement?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SpreadProperty',
|
|
_SpreadProperty?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Super',
|
|
_Super?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SwitchCase',
|
|
_SwitchCase?: void,
|
|
consequent: Array<Statement>,
|
|
test: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SwitchStatement',
|
|
_SwitchStatement?: void,
|
|
cases: Array<SwitchCase>,
|
|
discriminant: Expression,
|
|
lexical: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TaggedTemplateExpression',
|
|
_TaggedTemplateExpression?: void,
|
|
quasi: TemplateLiteral,
|
|
tag: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TemplateElement',
|
|
_TemplateElement?: void,
|
|
tail: boolean,
|
|
value: {cooked: string, raw: string},
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TemplateLiteral',
|
|
_TemplateLiteral?: void,
|
|
expressions: Array<Expression>,
|
|
quasis: Array<TemplateElement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ThisExpression',
|
|
_ThisExpression?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ThrowStatement',
|
|
_ThrowStatement?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TryStatement',
|
|
_TryStatement?: void,
|
|
block: BlockStatement,
|
|
finalizer: ?BlockStatement,
|
|
guardedHandlers: Array<CatchClause>,
|
|
handler: ?CatchClause,
|
|
handlers: ?Array<CatchClause>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'UnaryExpression',
|
|
_UnaryExpression?: void,
|
|
argument: Expression,
|
|
operator: UnaryOperator,
|
|
prefix: true,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'UpdateExpression',
|
|
_UpdateExpression?: void,
|
|
argument: Expression,
|
|
operator: UpdateOperator,
|
|
prefix: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'VariableDeclaration',
|
|
_VariableDeclaration?: void,
|
|
declarations: Array<VariableDeclarator>,
|
|
kind: 'var' | 'let' | 'const',
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'VariableDeclarator',
|
|
_VariableDeclarator?: void,
|
|
id: Pattern,
|
|
init: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'WhileStatement',
|
|
_WhileStatement?: void,
|
|
body: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'WithStatement',
|
|
_WithStatement?: void,
|
|
body: Statement,
|
|
object: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'YieldExpression',
|
|
_YieldExpression?: void,
|
|
argument: ?Expression,
|
|
delegate: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExportAllDeclaration',
|
|
_ExportAllDeclaration?: void,
|
|
exported: Node,
|
|
source: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExportDefaultDeclaration',
|
|
_ExportDefaultDeclaration?: void,
|
|
declaration: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExportNamedDeclaration',
|
|
_ExportNamedDeclaration?: void,
|
|
declaration: Node,
|
|
source: Literal,
|
|
specifiers: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExportDefaultSpecifier',
|
|
_ExportDefaultSpecifier?: void,
|
|
exported: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExportNamespaceSpecifier',
|
|
_ExportNamespaceSpecifier?: void,
|
|
exported: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExportSpecifier',
|
|
_ExportSpecifier?: void,
|
|
local: Node,
|
|
exported: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'AnyTypeAnnotation',
|
|
_AnyTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ArrayTypeAnnotation',
|
|
_ArrayTypeAnnotation?: void,
|
|
elementType: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BooleanLiteralTypeAnnotation',
|
|
_BooleanLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BooleanTypeAnnotation',
|
|
_BooleanTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassImplements',
|
|
_ClassImplements?: void,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
superClass: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ClassProperty',
|
|
_ClassProperty?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
static: boolean,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
value: ?Expression,
|
|
decorators: Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareClass',
|
|
_DeclareClass?: void,
|
|
body: ObjectTypeAnnotation,
|
|
extends: Array<InterfaceExtends>,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareFunction',
|
|
_DeclareFunction?: void,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareModule',
|
|
_DeclareModule?: void,
|
|
body: BlockStatement,
|
|
id: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareVariable',
|
|
_DeclareVariable?: void,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'FunctionTypeAnnotation',
|
|
_FunctionTypeAnnotation?: void,
|
|
params: Array<FunctionTypeParam>,
|
|
rest: ?FunctionTypeParam,
|
|
returnType: Type,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'FunctionTypeParam',
|
|
_FunctionTypeParam?: void,
|
|
name: Identifier,
|
|
optional: boolean,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'GenericTypeAnnotation',
|
|
_GenericTypeAnnotation?: void,
|
|
id: Node,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'InterfaceExtends',
|
|
_InterfaceExtends?: void,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'InterfaceDeclaration',
|
|
_InterfaceDeclaration?: void,
|
|
body: ObjectTypeAnnotation,
|
|
extends: Array<InterfaceExtends>,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'IntersectionTypeAnnotation',
|
|
_IntersectionTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'MixedTypeAnnotation',
|
|
_MixedTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NullableTypeAnnotation',
|
|
_NullableTypeAnnotation?: void,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NumberLiteralTypeAnnotation',
|
|
_NumberLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: number,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NumberTypeAnnotation',
|
|
_NumberTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'StringLiteralTypeAnnotation',
|
|
_StringLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: string,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'StringTypeAnnotation',
|
|
_StringTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TupleTypeAnnotation',
|
|
_TupleTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeofTypeAnnotation',
|
|
_TypeofTypeAnnotation?: void,
|
|
argument: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeAlias',
|
|
_TypeAlias?: void,
|
|
id: Identifier,
|
|
right: Type,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeAnnotation',
|
|
_TypeAnnotation?: void,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeCastExpression',
|
|
_TypeCastExpression?: void,
|
|
expression: Expression,
|
|
typeAnnotation: TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeParameterDeclaration',
|
|
_TypeParameterDeclaration?: void,
|
|
params: Array<Identifier>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeParameterInstantiation',
|
|
_TypeParameterInstantiation?: void,
|
|
params: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectTypeAnnotation',
|
|
_ObjectTypeAnnotation?: void,
|
|
callProperties: Array<ObjectTypeCallProperty>,
|
|
indexers: Array<ObjectTypeIndexer>,
|
|
properties: Array<ObjectTypeProperty>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectTypeCallProperty',
|
|
_ObjectTypeCallProperty?: void,
|
|
static: boolean,
|
|
value: FunctionTypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectTypeIndexer',
|
|
_ObjectTypeIndexer?: void,
|
|
id: Identifier,
|
|
key: Type,
|
|
value: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectTypeProperty',
|
|
_ObjectTypeProperty?: void,
|
|
key: Node,
|
|
optional: boolean,
|
|
value: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'QualifiedTypeIdentifier',
|
|
_QualifiedTypeIdentifier?: void,
|
|
id: Identifier,
|
|
qualification: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'UnionTypeAnnotation',
|
|
_UnionTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'VoidTypeAnnotation',
|
|
_VoidTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXAttribute',
|
|
_JSXAttribute?: void,
|
|
name: Node,
|
|
value: ?Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXClosingElement',
|
|
_JSXClosingElement?: void,
|
|
name: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXElement',
|
|
_JSXElement?: void,
|
|
children: Array<Node>,
|
|
closingElement: ?JSXClosingElement,
|
|
openingElement: JSXOpeningElement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXEmptyExpression',
|
|
_JSXEmptyExpression?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXExpressionContainer',
|
|
_JSXExpressionContainer?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXIdentifier',
|
|
_JSXIdentifier?: void,
|
|
name: string,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXMemberExpression',
|
|
_JSXMemberExpression?: void,
|
|
computed: boolean,
|
|
object: Node,
|
|
property: JSXIdentifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXNamespacedName',
|
|
_JSXNamespacedName?: void,
|
|
name: JSXIdentifier,
|
|
namespace: JSXIdentifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXOpeningElement',
|
|
_JSXOpeningElement?: void,
|
|
attributes: Array<Node>,
|
|
name: Array<Node>,
|
|
selfClosing: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'JSXSpreadAttribute',
|
|
_JSXSpreadAttribute?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Pattern = {
|
|
type: 'ArrayPattern',
|
|
_ArrayPattern?: void,
|
|
elements: Array<?Node>,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'AssignmentPattern',
|
|
_AssignmentPattern?: void,
|
|
left: Pattern,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'Identifier',
|
|
_Identifier?: void,
|
|
name: string,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectPattern',
|
|
_ObjectPattern?: void,
|
|
properties: Array<Node>,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'RestElement',
|
|
_RestElement?: void,
|
|
argument: Pattern,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Statement = {
|
|
type: 'BlockStatement',
|
|
_BlockStatement?: void,
|
|
body: Array<Statement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BreakStatement',
|
|
_BreakStatement?: void,
|
|
label: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ContinueStatement',
|
|
_ContinueStatement?: void,
|
|
label: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DoWhileStatement',
|
|
_DoWhileStatement?: void,
|
|
body: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'EmptyStatement',
|
|
_EmptyStatement?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ExpressionStatement',
|
|
_ExpressionStatement?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ForInStatement',
|
|
_ForInStatement?: void,
|
|
body: Statement,
|
|
left: Node,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ForOfStatement',
|
|
_ForOfStatement?: void,
|
|
body: Statement,
|
|
left: Node,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ForStatement',
|
|
_ForStatement?: void,
|
|
init: ?Node,
|
|
test: ?Expression,
|
|
update: ?Expression,
|
|
body: Statement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'IfStatement',
|
|
_IfStatement?: void,
|
|
alternate: ?Statement,
|
|
consequent: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'LabeledStatement',
|
|
_LabeledStatement?: void,
|
|
body: Statement,
|
|
label: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ReturnStatement',
|
|
_ReturnStatement?: void,
|
|
argument: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'SwitchStatement',
|
|
_SwitchStatement?: void,
|
|
cases: Array<SwitchCase>,
|
|
discriminant: Expression,
|
|
lexical: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ThrowStatement',
|
|
_ThrowStatement?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TryStatement',
|
|
_TryStatement?: void,
|
|
block: BlockStatement,
|
|
finalizer: ?BlockStatement,
|
|
guardedHandlers: Array<CatchClause>,
|
|
handler: ?CatchClause,
|
|
handlers: ?Array<CatchClause>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'WhileStatement',
|
|
_WhileStatement?: void,
|
|
body: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'WithStatement',
|
|
_WithStatement?: void,
|
|
body: Statement,
|
|
object: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareClass',
|
|
_DeclareClass?: void,
|
|
body: ObjectTypeAnnotation,
|
|
extends: Array<InterfaceExtends>,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareFunction',
|
|
_DeclareFunction?: void,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareModule',
|
|
_DeclareModule?: void,
|
|
body: BlockStatement,
|
|
id: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'DeclareVariable',
|
|
_DeclareVariable?: void,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'InterfaceDeclaration',
|
|
_InterfaceDeclaration?: void,
|
|
body: ObjectTypeAnnotation,
|
|
extends: Array<InterfaceExtends>,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TypeAlias',
|
|
_TypeAlias?: void,
|
|
id: Identifier,
|
|
right: Type,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Type = {
|
|
type: 'AnyTypeAnnotation',
|
|
_AnyTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ArrayTypeAnnotation',
|
|
_ArrayTypeAnnotation?: void,
|
|
elementType: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BooleanLiteralTypeAnnotation',
|
|
_BooleanLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'BooleanTypeAnnotation',
|
|
_BooleanTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'FunctionTypeAnnotation',
|
|
_FunctionTypeAnnotation?: void,
|
|
params: Array<FunctionTypeParam>,
|
|
rest: ?FunctionTypeParam,
|
|
returnType: Type,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'GenericTypeAnnotation',
|
|
_GenericTypeAnnotation?: void,
|
|
id: Node,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'IntersectionTypeAnnotation',
|
|
_IntersectionTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'MixedTypeAnnotation',
|
|
_MixedTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NullableTypeAnnotation',
|
|
_NullableTypeAnnotation?: void,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NumberLiteralTypeAnnotation',
|
|
_NumberLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: number,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'NumberTypeAnnotation',
|
|
_NumberTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'StringLiteralTypeAnnotation',
|
|
_StringLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: string,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'StringTypeAnnotation',
|
|
_StringTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'TupleTypeAnnotation',
|
|
_TupleTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'ObjectTypeAnnotation',
|
|
_ObjectTypeAnnotation?: void,
|
|
callProperties: Array<ObjectTypeCallProperty>,
|
|
indexers: Array<ObjectTypeIndexer>,
|
|
properties: Array<ObjectTypeProperty>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'UnionTypeAnnotation',
|
|
_UnionTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
} | {
|
|
type: 'VoidTypeAnnotation',
|
|
_VoidTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// Concrete Types. Nothing can extend these.
|
|
|
|
export type CommentLine = {
|
|
type: 'CommentLine',
|
|
_CommentLine?: void,
|
|
value: string,
|
|
end: number,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
};
|
|
|
|
export type CommentBlock = {
|
|
type: 'CommentBlock',
|
|
_CommentBlock?: void,
|
|
value: string,
|
|
end: number,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
};
|
|
|
|
// Babel concrete types.
|
|
|
|
export type ArrayExpression = {
|
|
type: 'ArrayExpression',
|
|
_ArrayExpression?: void,
|
|
elements: Array<?Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ArrayPattern = {
|
|
type: 'ArrayPattern',
|
|
_ArrayPattern?: void,
|
|
elements: Array<?Node>,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ArrowFunctionExpression = {
|
|
type: 'ArrowFunctionExpression',
|
|
_ArrowFunctionExpression?: void,
|
|
body: Node,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
};
|
|
|
|
type AssignmentOperator =
|
|
'=' |
|
|
'+=' |
|
|
'-=' |
|
|
'*=' |
|
|
'/=' |
|
|
'%=' |
|
|
'<<=' |
|
|
'>>=' |
|
|
'>>>=' |
|
|
'|=' |
|
|
'^=' |
|
|
'&=';
|
|
|
|
export type AssignmentExpression = {
|
|
type: 'AssignmentExpression',
|
|
_AssignmentExpression?: void,
|
|
left: Pattern,
|
|
operator: AssignmentOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type AssignmentPattern = {
|
|
type: 'AssignmentPattern',
|
|
_AssignmentPattern?: void,
|
|
left: Pattern,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type AwaitExpression = {
|
|
type: 'AwaitExpression',
|
|
_AwaitExpression?: void,
|
|
all: boolean,
|
|
argument: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
type BinaryOperator =
|
|
'==' |
|
|
'!=' |
|
|
'===' |
|
|
'!==' |
|
|
'<' |
|
|
'<=' |
|
|
'>' |
|
|
'>=' |
|
|
'<<' |
|
|
'>>' |
|
|
'>>>' |
|
|
'+' |
|
|
'-' |
|
|
'*' |
|
|
'/' |
|
|
'%' |
|
|
'&' |
|
|
'|' |
|
|
'^' |
|
|
'in' |
|
|
'instanceof' |
|
|
'..';
|
|
|
|
export type BinaryExpression = {
|
|
type: 'BinaryExpression',
|
|
_BinaryExpression?: void,
|
|
left: Expression,
|
|
operator: BinaryOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: What is this?
|
|
export type BindExpression = {
|
|
type: 'BindExpression',
|
|
_BindExpression?: void,
|
|
callee: Node,
|
|
object: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type BlockStatement = {
|
|
type: 'BlockStatement',
|
|
_BlockStatement?: void,
|
|
body: Array<Statement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type BreakStatement = {
|
|
type: 'BreakStatement',
|
|
_BreakStatement?: void,
|
|
label: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type CallExpression = {
|
|
type: 'CallExpression',
|
|
_CallExpression?: void,
|
|
arguments: Array<Node>,
|
|
callee: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type CatchClause = {
|
|
type: 'CatchClause',
|
|
_CatchClause?: void,
|
|
body: BlockStatement,
|
|
param: Pattern,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ClassBody = {
|
|
type: 'ClassBody',
|
|
_ClassBody?: void,
|
|
body: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ClassDeclaration = {
|
|
type: 'ClassDeclaration',
|
|
_ClassDeclaration?: void,
|
|
body: ClassBody,
|
|
id: ?Identifier,
|
|
superClass: ?Expression,
|
|
decorators: any,
|
|
superTypeParameters: any,
|
|
typeParameters: any,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ClassExpression = {
|
|
type: 'ClassExpression',
|
|
_ClassExpression?: void,
|
|
body: ClassBody,
|
|
id: ?Identifier,
|
|
superClass: ?Expression,
|
|
decorators: any,
|
|
superTypeParameters: any,
|
|
typeParameters: any,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ComprehensionBlock = {
|
|
type: 'ComprehensionBlock',
|
|
_ComprehensionBlock?: void,
|
|
each: boolean,
|
|
left: Pattern,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ComprehensionExpression = {
|
|
type: 'ComprehensionExpression',
|
|
_ComprehensionExpression?: void,
|
|
body: Expression,
|
|
blocks: Array<ComprehensionBlock>,
|
|
filter: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ConditionalExpression = {
|
|
type: 'ConditionalExpression',
|
|
_ConditionalExpression?: void,
|
|
alternate: Expression,
|
|
consequent: Expression,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ContinueStatement = {
|
|
type: 'ContinueStatement',
|
|
_ContinueStatement?: void,
|
|
label: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type Decorator = {
|
|
type: 'Decorator',
|
|
_Decorator?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type DebuggerStatement = {
|
|
type: 'DebuggerStatement',
|
|
_DebuggerStatement?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type DoWhileStatement = {
|
|
type: 'DoWhileStatement',
|
|
_DoWhileStatement?: void,
|
|
body: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type DoExpression = {
|
|
type: 'DoExpression',
|
|
_DoExpression?: void,
|
|
body: Statement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type EmptyStatement = {
|
|
type: 'EmptyStatement',
|
|
_EmptyStatement?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ExpressionStatement = {
|
|
type: 'ExpressionStatement',
|
|
_ExpressionStatement?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type File = {
|
|
type: 'File',
|
|
_File?: void,
|
|
program: Program,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ForInStatement = {
|
|
type: 'ForInStatement',
|
|
_ForInStatement?: void,
|
|
body: Statement,
|
|
left: Node,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ForOfStatement = {
|
|
type: 'ForOfStatement',
|
|
_ForOfStatement?: void,
|
|
body: Statement,
|
|
left: Node,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ForStatement = {
|
|
type: 'ForStatement',
|
|
_ForStatement?: void,
|
|
init: ?Node,
|
|
test: ?Expression,
|
|
update: ?Expression,
|
|
body: Statement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type FunctionDeclaration = {
|
|
type: 'FunctionDeclaration',
|
|
_FunctionDeclaration?: void,
|
|
body: BlockStatement,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
};
|
|
|
|
export type FunctionExpression = {
|
|
type: 'FunctionExpression',
|
|
_FunctionExpression?: void,
|
|
body: BlockStatement,
|
|
id: ?Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
async: boolean,
|
|
defaults: Array<?Expression>,
|
|
expression: boolean,
|
|
generator: boolean,
|
|
params: Array<Pattern>,
|
|
rest: ?Identifier,
|
|
returnType: ?TypeAnnotation,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
};
|
|
|
|
export type Identifier = {
|
|
type: 'Identifier',
|
|
_Identifier?: void,
|
|
name: string,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type IfStatement = {
|
|
type: 'IfStatement',
|
|
_IfStatement?: void,
|
|
alternate: ?Statement,
|
|
consequent: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ImportDefaultSpecifier = {
|
|
type: 'ImportDefaultSpecifier',
|
|
_ImportDefaultSpecifier?: void,
|
|
local: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ImportNamespaceSpecifier = {
|
|
type: 'ImportNamespaceSpecifier',
|
|
_ImportNamespaceSpecifier?: void,
|
|
local: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ImportDeclaration = {
|
|
type: 'ImportDeclaration',
|
|
_ImportDeclaration?: void,
|
|
specifiers: Array<Node>,
|
|
source: Literal,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ImportSpecifier = {
|
|
type: 'ImportSpecifier',
|
|
_ImportSpecifier?: void,
|
|
imported: Node,
|
|
local: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type LabeledStatement = {
|
|
type: 'LabeledStatement',
|
|
_LabeledStatement?: void,
|
|
body: Statement,
|
|
label: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Literal = {
|
|
type: 'Literal',
|
|
_Literal?: void,
|
|
raw: string,
|
|
regex: ?{pattern: string, flags: string},
|
|
value: ?(string | boolean | number | RegExp),
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
type LogicalOperator = '||' | '&&';
|
|
|
|
export type LogicalExpression = {
|
|
type: 'LogicalExpression',
|
|
_LogicalExpression?: void,
|
|
left: Expression,
|
|
operator: LogicalOperator,
|
|
right: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type MemberExpression = {
|
|
type: 'MemberExpression',
|
|
_MemberExpression?: void,
|
|
computed: boolean,
|
|
object: Expression,
|
|
property: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type MetaProperty = {
|
|
type: 'MetaProperty',
|
|
_MetaProperty?: void,
|
|
meta: Node,
|
|
property: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type MethodDefinition = {
|
|
type: 'MethodDefinition',
|
|
_MethodDefinition?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
kind: 'constructor' | 'method' | 'get' | 'set',
|
|
static: boolean,
|
|
value: FunctionExpression,
|
|
decorators: ?Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type NewExpression = {
|
|
type: 'NewExpression',
|
|
_NewExpression?: void,
|
|
arguments: Array<Node>,
|
|
callee: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Noop = {
|
|
type: 'Noop',
|
|
_Noop?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ObjectExpression = {
|
|
type: 'ObjectExpression',
|
|
_ObjectExpression?: void,
|
|
properties: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ObjectPattern = {
|
|
type: 'ObjectPattern',
|
|
_ObjectPattern?: void,
|
|
properties: Array<Node>,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Program = {
|
|
type: 'Program',
|
|
_Program?: void,
|
|
body: Array<Statement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Property = {
|
|
type: 'Property',
|
|
_Property?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
kind: 'init' | 'get' | 'set',
|
|
method: boolean,
|
|
shorthand: boolean,
|
|
value: Node,
|
|
decorators: ?Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type RestElement = {
|
|
type: 'RestElement',
|
|
_RestElement?: void,
|
|
argument: Pattern,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ReturnStatement = {
|
|
type: 'ReturnStatement',
|
|
_ReturnStatement?: void,
|
|
argument: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type SequenceExpression = {
|
|
type: 'SequenceExpression',
|
|
_SequenceExpression?: void,
|
|
expression: Array<Expression>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type SpreadElement = {
|
|
type: 'SpreadElement',
|
|
_SpreadElement?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type SpreadProperty = {
|
|
type: 'SpreadProperty',
|
|
_SpreadProperty?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type Super = {
|
|
type: 'Super',
|
|
_Super?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type SwitchCase = {
|
|
type: 'SwitchCase',
|
|
_SwitchCase?: void,
|
|
consequent: Array<Statement>,
|
|
test: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type SwitchStatement = {
|
|
type: 'SwitchStatement',
|
|
_SwitchStatement?: void,
|
|
cases: Array<SwitchCase>,
|
|
discriminant: Expression,
|
|
lexical: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TaggedTemplateExpression = {
|
|
type: 'TaggedTemplateExpression',
|
|
_TaggedTemplateExpression?: void,
|
|
quasi: TemplateLiteral,
|
|
tag: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TemplateElement = {
|
|
type: 'TemplateElement',
|
|
_TemplateElement?: void,
|
|
tail: boolean,
|
|
value: {cooked: string, raw: string},
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TemplateLiteral = {
|
|
type: 'TemplateLiteral',
|
|
_TemplateLiteral?: void,
|
|
expressions: Array<Expression>,
|
|
quasis: Array<TemplateElement>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ThisExpression = {
|
|
type: 'ThisExpression',
|
|
_ThisExpression?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ThrowStatement = {
|
|
type: 'ThrowStatement',
|
|
_ThrowStatement?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TryStatement = {
|
|
type: 'TryStatement',
|
|
_TryStatement?: void,
|
|
block: BlockStatement,
|
|
finalizer: ?BlockStatement,
|
|
guardedHandlers: Array<CatchClause>,
|
|
handler: ?CatchClause,
|
|
handlers: ?Array<CatchClause>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
|
|
|
|
export type UnaryExpression = {
|
|
type: 'UnaryExpression',
|
|
_UnaryExpression?: void,
|
|
argument: Expression,
|
|
operator: UnaryOperator,
|
|
prefix: true,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
type UpdateOperator = '++' | '--';
|
|
|
|
export type UpdateExpression = {
|
|
type: 'UpdateExpression',
|
|
_UpdateExpression?: void,
|
|
argument: Expression,
|
|
operator: UpdateOperator,
|
|
prefix: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type VariableDeclaration = {
|
|
type: 'VariableDeclaration',
|
|
_VariableDeclaration?: void,
|
|
declarations: Array<VariableDeclarator>,
|
|
kind: 'var' | 'let' | 'const',
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type VariableDeclarator = {
|
|
type: 'VariableDeclarator',
|
|
_VariableDeclarator?: void,
|
|
id: Pattern,
|
|
init: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type WhileStatement = {
|
|
type: 'WhileStatement',
|
|
_WhileStatement?: void,
|
|
body: Statement,
|
|
test: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type WithStatement = {
|
|
type: 'WithStatement',
|
|
_WithStatement?: void,
|
|
body: Statement,
|
|
object: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type YieldExpression = {
|
|
type: 'YieldExpression',
|
|
_YieldExpression?: void,
|
|
argument: ?Expression,
|
|
delegate: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ExportAllDeclaration = {
|
|
type: 'ExportAllDeclaration',
|
|
_ExportAllDeclaration?: void,
|
|
exported: Node,
|
|
source: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ExportDefaultDeclaration = {
|
|
type: 'ExportDefaultDeclaration',
|
|
_ExportDefaultDeclaration?: void,
|
|
declaration: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ExportNamedDeclaration = {
|
|
type: 'ExportNamedDeclaration',
|
|
_ExportNamedDeclaration?: void,
|
|
declaration: Node,
|
|
source: Literal,
|
|
specifiers: Array<Node>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ExportDefaultSpecifier = {
|
|
type: 'ExportDefaultSpecifier',
|
|
_ExportDefaultSpecifier?: void,
|
|
exported: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ExportNamespaceSpecifier = {
|
|
type: 'ExportNamespaceSpecifier',
|
|
_ExportNamespaceSpecifier?: void,
|
|
exported: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type ExportSpecifier = {
|
|
type: 'ExportSpecifier',
|
|
_ExportSpecifier?: void,
|
|
local: Node,
|
|
exported: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type AnyTypeAnnotation = {
|
|
type: 'AnyTypeAnnotation',
|
|
_AnyTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ArrayTypeAnnotation = {
|
|
type: 'ArrayTypeAnnotation',
|
|
_ArrayTypeAnnotation?: void,
|
|
elementType: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type BooleanLiteralTypeAnnotation = {
|
|
type: 'BooleanLiteralTypeAnnotation',
|
|
_BooleanLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type BooleanTypeAnnotation = {
|
|
type: 'BooleanTypeAnnotation',
|
|
_BooleanTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ClassImplements = {
|
|
type: 'ClassImplements',
|
|
_ClassImplements?: void,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
superClass: ?Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ClassProperty = {
|
|
type: 'ClassProperty',
|
|
_ClassProperty?: void,
|
|
computed: boolean,
|
|
key: Node,
|
|
static: boolean,
|
|
typeAnnotation: ?TypeAnnotation,
|
|
value: ?Expression,
|
|
decorators: Array<Decorator>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type DeclareClass = {
|
|
type: 'DeclareClass',
|
|
_DeclareClass?: void,
|
|
body: ObjectTypeAnnotation,
|
|
extends: Array<InterfaceExtends>,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type DeclareFunction = {
|
|
type: 'DeclareFunction',
|
|
_DeclareFunction?: void,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type DeclareModule = {
|
|
type: 'DeclareModule',
|
|
_DeclareModule?: void,
|
|
body: BlockStatement,
|
|
id: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
// TODO: Make this correct.
|
|
export type DeclareVariable = {
|
|
type: 'DeclareVariable',
|
|
_DeclareVariable?: void,
|
|
id: Identifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type FunctionTypeAnnotation = {
|
|
type: 'FunctionTypeAnnotation',
|
|
_FunctionTypeAnnotation?: void,
|
|
params: Array<FunctionTypeParam>,
|
|
rest: ?FunctionTypeParam,
|
|
returnType: Type,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type FunctionTypeParam = {
|
|
type: 'FunctionTypeParam',
|
|
_FunctionTypeParam?: void,
|
|
name: Identifier,
|
|
optional: boolean,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type GenericTypeAnnotation = {
|
|
type: 'GenericTypeAnnotation',
|
|
_GenericTypeAnnotation?: void,
|
|
id: Node,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type InterfaceExtends = {
|
|
type: 'InterfaceExtends',
|
|
_InterfaceExtends?: void,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterInstantiation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type InterfaceDeclaration = {
|
|
type: 'InterfaceDeclaration',
|
|
_InterfaceDeclaration?: void,
|
|
body: ObjectTypeAnnotation,
|
|
extends: Array<InterfaceExtends>,
|
|
id: Identifier,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type IntersectionTypeAnnotation = {
|
|
type: 'IntersectionTypeAnnotation',
|
|
_IntersectionTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type MixedTypeAnnotation = {
|
|
type: 'MixedTypeAnnotation',
|
|
_MixedTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type NullableTypeAnnotation = {
|
|
type: 'NullableTypeAnnotation',
|
|
_NullableTypeAnnotation?: void,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type NumberLiteralTypeAnnotation = {
|
|
type: 'NumberLiteralTypeAnnotation',
|
|
_NumberLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: number,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type NumberTypeAnnotation = {
|
|
type: 'NumberTypeAnnotation',
|
|
_NumberTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type StringLiteralTypeAnnotation = {
|
|
type: 'StringLiteralTypeAnnotation',
|
|
_StringLiteralTypeAnnotation?: void,
|
|
raw: string,
|
|
value: string,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type StringTypeAnnotation = {
|
|
type: 'StringTypeAnnotation',
|
|
_StringTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TupleTypeAnnotation = {
|
|
type: 'TupleTypeAnnotation',
|
|
_TupleTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TypeofTypeAnnotation = {
|
|
type: 'TypeofTypeAnnotation',
|
|
_TypeofTypeAnnotation?: void,
|
|
argument: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TypeAlias = {
|
|
type: 'TypeAlias',
|
|
_TypeAlias?: void,
|
|
id: Identifier,
|
|
right: Type,
|
|
typeParameters: ?TypeParameterDeclaration,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TypeAnnotation = {
|
|
type: 'TypeAnnotation',
|
|
_TypeAnnotation?: void,
|
|
typeAnnotation: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TypeCastExpression = {
|
|
type: 'TypeCastExpression',
|
|
_TypeCastExpression?: void,
|
|
expression: Expression,
|
|
typeAnnotation: TypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TypeParameterDeclaration = {
|
|
type: 'TypeParameterDeclaration',
|
|
_TypeParameterDeclaration?: void,
|
|
params: Array<Identifier>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type TypeParameterInstantiation = {
|
|
type: 'TypeParameterInstantiation',
|
|
_TypeParameterInstantiation?: void,
|
|
params: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ObjectTypeAnnotation = {
|
|
type: 'ObjectTypeAnnotation',
|
|
_ObjectTypeAnnotation?: void,
|
|
callProperties: Array<ObjectTypeCallProperty>,
|
|
indexers: Array<ObjectTypeIndexer>,
|
|
properties: Array<ObjectTypeProperty>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ObjectTypeCallProperty = {
|
|
type: 'ObjectTypeCallProperty',
|
|
_ObjectTypeCallProperty?: void,
|
|
static: boolean,
|
|
value: FunctionTypeAnnotation,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ObjectTypeIndexer = {
|
|
type: 'ObjectTypeIndexer',
|
|
_ObjectTypeIndexer?: void,
|
|
id: Identifier,
|
|
key: Type,
|
|
value: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type ObjectTypeProperty = {
|
|
type: 'ObjectTypeProperty',
|
|
_ObjectTypeProperty?: void,
|
|
key: Node,
|
|
optional: boolean,
|
|
value: Type,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type QualifiedTypeIdentifier = {
|
|
type: 'QualifiedTypeIdentifier',
|
|
_QualifiedTypeIdentifier?: void,
|
|
id: Identifier,
|
|
qualification: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type UnionTypeAnnotation = {
|
|
type: 'UnionTypeAnnotation',
|
|
_UnionTypeAnnotation?: void,
|
|
types: Array<Type>,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type VoidTypeAnnotation = {
|
|
type: 'VoidTypeAnnotation',
|
|
_VoidTypeAnnotation?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXAttribute = {
|
|
type: 'JSXAttribute',
|
|
_JSXAttribute?: void,
|
|
name: Node,
|
|
value: ?Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXClosingElement = {
|
|
type: 'JSXClosingElement',
|
|
_JSXClosingElement?: void,
|
|
name: Node,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXElement = {
|
|
type: 'JSXElement',
|
|
_JSXElement?: void,
|
|
children: Array<Node>,
|
|
closingElement: ?JSXClosingElement,
|
|
openingElement: JSXOpeningElement,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXEmptyExpression = {
|
|
type: 'JSXEmptyExpression',
|
|
_JSXEmptyExpression?: void,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXExpressionContainer = {
|
|
type: 'JSXExpressionContainer',
|
|
_JSXExpressionContainer?: void,
|
|
expression: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXIdentifier = {
|
|
type: 'JSXIdentifier',
|
|
_JSXIdentifier?: void,
|
|
name: string,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXMemberExpression = {
|
|
type: 'JSXMemberExpression',
|
|
_JSXMemberExpression?: void,
|
|
computed: boolean,
|
|
object: Node,
|
|
property: JSXIdentifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXNamespacedName = {
|
|
type: 'JSXNamespacedName',
|
|
_JSXNamespacedName?: void,
|
|
name: JSXIdentifier,
|
|
namespace: JSXIdentifier,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXOpeningElement = {
|
|
type: 'JSXOpeningElement',
|
|
_JSXOpeningElement?: void,
|
|
attributes: Array<Node>,
|
|
name: Array<Node>,
|
|
selfClosing: boolean,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|
|
|
|
export type JSXSpreadAttribute = {
|
|
type: 'JSXSpreadAttribute',
|
|
_JSXSpreadAttribute?: void,
|
|
argument: Expression,
|
|
end: number,
|
|
innerComments: ?Array<Comment>,
|
|
leadingComments: ?Array<Comment>,
|
|
loc: {
|
|
end: {column: number, line: number},
|
|
start: {column: number, line: number},
|
|
},
|
|
start: number,
|
|
trailingComments: ?Array<Comment>,
|
|
};
|