10339 lines
247 KiB
Plaintext
10339 lines
247 KiB
Plaintext
exports[`test printBinaryExpression.js 1`] = `
|
|
"\'use babel\';
|
|
/* @flow */
|
|
|
|
/*
|
|
* Copyright (c) 2015-present, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the license found in the LICENSE file in
|
|
* the root directory of this source tree.
|
|
*/
|
|
|
|
import type {BinaryExpression} from \'./types\';
|
|
|
|
function printBinaryExpression(
|
|
node: BinaryExpression,
|
|
) {
|
|
console.log(node);
|
|
}
|
|
|
|
module.exports = printBinaryExpression;
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
\"use babel\";
|
|
/* @flow */
|
|
/*
|
|
* Copyright (c) 2015-present, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the license found in the LICENSE file in
|
|
* the root directory of this source tree.
|
|
*/
|
|
import type { BinaryExpression } from \"./types\";
|
|
|
|
function printBinaryExpression(node: BinaryExpression) {
|
|
console.log(node);
|
|
}
|
|
|
|
module.exports = printBinaryExpression;
|
|
"
|
|
`;
|
|
|
|
exports[`test types.js 1`] = `
|
|
"/**
|
|
* @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>;
|
|
};
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
/**
|
|
* @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>
|
|
};
|
|
"
|
|
`;
|