Skip to content

Instantly share code, notes, and snippets.

@b2whats

b2whats/babel-types-described.js

Forked from forivall/babel-types-described.js
Created July 3, 2018 10:45
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save b2whats/f279776fc3e648e3831e1e952fbb284f to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save b2whats/f279776fc3e648e3831e1e952fbb284f to your computer and use it in GitHub Desktop.
Download ZIP
babel-types
Raw
babel-types-described.js
{ __esModule: true,
is: [function is(type /*: string*/, node /*: Object*/, opts /*:: ?: Object*/, skipAliasCheck /*:: ?: boolean*/) /*: boolean*/ ],
isType: [function isType(nodeType /*: string*/, targetType /*: string*/) /*: boolean*/ ],
validate: [function validate(node, key, val) ],
shallowEqual: [function shallowEqual(actual /*: Object*/, expected /*: Object*/) /*: boolean*/ ],
appendToMemberExpression: [function appendToMemberExpression(member /*: Object*/, append /*: Object*/, computed /*:: ?: boolean*/) /*: Object*/ ],
prependToMemberExpression: [function prependToMemberExpression(member /*: Object*/, prepend /*: Object*/) /*: Object*/ ],
ensureBlock: [function ensureBlock(node /*: Object*/) ],
clone: [function clone(node /*: Object*/) /*: Object*/ ],
cloneDeep: [function cloneDeep(node /*: Object*/) /*: Object*/ ],
buildMatchMemberExpression: [function buildMatchMemberExpression(match /*:string*/, allowPartial /*:: ?: boolean*/) /*: Function*/ ],
removeComments: [function removeComments(node /*: Object*/) /*: Object*/ ],
inheritsComments: [function inheritsComments(child /*: Object*/, parent /*: Object*/) /*: Object*/ ],
inheritTrailingComments: [function inheritTrailingComments(child, parent) ],
inheritLeadingComments: [function inheritLeadingComments(child, parent) ],
inheritInnerComments: [function inheritInnerComments(child, parent) ],
inherits: [function inherits(child /*: Object*/, parent /*: Object*/) /*: Object*/ ],
directive: [function builder() ],
STATEMENT_OR_BLOCK_KEYS: [ 'consequent', 'body', 'alternate' ],
FLATTENABLE_KEYS: [ 'body', 'expressions' ],
FOR_INIT_KEYS: [ 'left', 'init' ],
COMMENT_KEYS: [ 'leadingComments', 'trailingComments', 'innerComments' ],
INHERIT_KEYS:
{ optional: [ 'typeAnnotation', 'typeParameters', 'returnType' ],
force: [ '_scopeInfo', '_paths', 'start', 'loc', 'end' ] },
BOOLEAN_NUMBER_BINARY_OPERATORS: [ '>', '<', '>=', '<=' ],
EQUALITY_BINARY_OPERATORS: [ '==', '===', '!=', '!==' ],
COMPARISON_BINARY_OPERATORS: [ '==', '===', '!=', '!==', 'in', 'instanceof' ],
BOOLEAN_BINARY_OPERATORS: [ '==', '===', '!=', '!==', 'in', 'instanceof', '>', '<', '>=', '<=' ],
NUMBER_BINARY_OPERATORS: [ '-', '/', '*', '**', '&', '|', '>>', '>>>', '<<', '^' ],
BOOLEAN_UNARY_OPERATORS: [ 'delete', '!' ],
NUMBER_UNARY_OPERATORS: [ '+', '-', '++', '--', '~' ],
STRING_UNARY_OPERATORS: [ 'typeof' ],
VISITOR_KEYS:
{ ArrayExpression: [ 'elements' ],
AssignmentExpression: [ 'left', 'right' ],
BinaryExpression: [ 'left', 'right' ],
Directive: [],
BlockStatement: [ 'directives', 'body' ],
BreakStatement: [ 'label' ],
CallExpression: [ 'callee', 'arguments' ],
CatchClause: [ 'param', 'body' ],
ConditionalExpression: [ 'test', 'consequent', 'alternate' ],
ContinueStatement: [ 'label' ],
DebuggerStatement: [],
DoWhileStatement: [ 'test', 'body' ],
EmptyStatement: [],
ExpressionStatement: [ 'expression' ],
File: [ 'program' ],
ForInStatement: [ 'left', 'right', 'body' ],
ForStatement: [ 'init', 'test', 'update', 'body' ],
FunctionDeclaration: [ 'id', 'params', 'body', 'returnType', 'typeParameters' ],
FunctionExpression: [ 'id', 'params', 'body', 'returnType', 'typeParameters' ],
Identifier: [ 'typeAnnotation' ],
IfStatement: [ 'test', 'consequent', 'alternate' ],
LabeledStatement: [ 'label', 'body' ],
StringLiteral: [],
NumberLiteral: [],
NullLiteral: [],
BooleanLiteral: [],
RegexLiteral: [],
LogicalExpression: [ 'left', 'right' ],
MemberExpression: [ 'object', 'property' ],
NewExpression: [ 'callee', 'arguments' ],
ObjectExpression: [ 'properties' ],
Program: [ 'directives', 'body' ],
Property: [ 'key', 'value', 'decorators' ],
RestElement: [ 'argument', 'typeAnnotation' ],
ReturnStatement: [ 'argument' ],
SequenceExpression: [ 'expressions' ],
SwitchCase: [ 'test', 'consequent' ],
SwitchStatement: [ 'discriminant', 'cases' ],
ThisExpression: [],
ThrowStatement: [ 'argument' ],
TryStatement: [ 'block', 'handler', 'finalizer' ],
UnaryExpression: [ 'argument' ],
UpdateExpression: [ 'argument' ],
VariableDeclaration: [ 'declarations' ],
VariableDeclarator: [ 'id', 'init' ],
WhileStatement: [ 'test', 'body' ],
WithStatement: [ 'object', 'body' ],
AssignmentPattern: [ 'left', 'right' ],
ArrayPattern: [ 'elements', 'typeAnnotation' ],
ArrowFunctionExpression: [ 'params', 'body', 'returnType' ],
ClassBody: [ 'body' ],
ClassDeclaration:
[ 'id',
'body',
'superClass',
'typeParameters',
'superTypeParameters',
'implements',
'decorators' ],
ClassExpression:
[ 'id',
'body',
'superClass',
'typeParameters',
'superTypeParameters',
'implements',
'decorators' ],
ExportAllDeclaration: [ 'source', 'exported' ],
ExportDefaultDeclaration: [ 'declaration' ],
ExportNamedDeclaration: [ 'declaration', 'specifiers', 'source' ],
ExportSpecifier: [ 'local', 'exported' ],
ForOfStatement: [ 'left', 'right', 'body' ],
ImportDeclaration: [ 'specifiers', 'source' ],
ImportDefaultSpecifier: [ 'local' ],
ImportNamespaceSpecifier: [ 'local' ],
ImportSpecifier: [ 'local', 'imported' ],
MetaProperty: [ 'meta', 'property' ],
MethodDefinition: [ 'key', 'value', 'decorators' ],
ObjectPattern: [ 'properties', 'typeAnnotation' ],
SpreadElement: [ 'argument' ],
Super: [],
TaggedTemplateExpression: [ 'tag', 'quasi' ],
TemplateElement: [],
TemplateLiteral: [ 'quasis', 'expressions' ],
YieldExpression: [ 'argument' ],
AnyTypeAnnotation: [],
ArrayTypeAnnotation: [ 'elementType' ],
BooleanTypeAnnotation: [],
BooleanLiteralTypeAnnotation: [],
ClassImplements: [ 'id', 'typeParameters' ],
ClassProperty: [ 'key', 'value', 'typeAnnotation', 'decorators' ],
DeclareClass: [ 'id', 'typeParameters', 'extends', 'body' ],
DeclareFunction: [ 'id' ],
DeclareModule: [ 'id', 'body' ],
DeclareVariable: [ 'id' ],
FunctionTypeAnnotation: [ 'typeParameters', 'params', 'rest', 'returnType' ],
FunctionTypeParam: [ 'name', 'typeAnnotation' ],
GenericTypeAnnotation: [ 'id', 'typeParameters' ],
InterfaceExtends: [ 'id', 'typeParameters' ],
InterfaceDeclaration: [ 'id', 'typeParameters', 'extends', 'body' ],
IntersectionTypeAnnotation: [ 'types' ],
MixedTypeAnnotation: [],
NullableTypeAnnotation: [ 'typeAnnotation' ],
NumberLiteralTypeAnnotation: [],
NumberTypeAnnotation: [],
StringLiteralTypeAnnotation: [],
StringTypeAnnotation: [],
TupleTypeAnnotation: [ 'types' ],
TypeofTypeAnnotation: [ 'argument' ],
TypeAlias: [ 'id', 'typeParameters', 'right' ],
TypeAnnotation: [ 'typeAnnotation' ],
TypeCastExpression: [ 'expression', 'typeAnnotation' ],
TypeParameterDeclaration: [ 'params' ],
TypeParameterInstantiation: [ 'params' ],
ObjectTypeAnnotation: [ 'properties', 'indexers', 'callProperties' ],
ObjectTypeCallProperty: [ 'value' ],
ObjectTypeIndexer: [ 'id', 'key', 'value' ],
ObjectTypeProperty: [ 'key', 'value' ],
QualifiedTypeIdentifier: [ 'id', 'qualification' ],
UnionTypeAnnotation: [ 'types' ],
VoidTypeAnnotation: [],
JSXAttribute: [ 'name', 'value' ],
JSXClosingElement: [ 'name' ],
JSXElement: [ 'openingElement', 'children', 'closingElement' ],
JSXEmptyExpression: [],
JSXExpressionContainer: [ 'expression' ],
JSXIdentifier: [],
JSXMemberExpression: [ 'object', 'property' ],
JSXNamespacedName: [ 'namespace', 'name' ],
JSXOpeningElement: [ 'name', 'attributes' ],
JSXSpreadAttribute: [ 'argument' ],
JSXText: [],
Noop: [],
ParenthesizedExpression: [ 'expression' ],
AwaitExpression: [ 'argument' ],
BindExpression: [ 'object', 'callee' ],
ComprehensionBlock: [ 'left', 'right' ],
ComprehensionExpression: [ 'filter', 'blocks', 'body' ],
Decorator: [ 'expression' ],
DoExpression: [ 'body' ],
ExportDefaultSpecifier: [ 'exported' ],
ExportNamespaceSpecifier: [ 'exported' ],
RestProperty: [ 'argument' ],
SpreadProperty: [ 'argument' ] },
ALIAS_KEYS:
{ ArrayExpression: [ 'Expression' ],
AssignmentExpression: [ 'Expression' ],
BinaryExpression: [ 'Binary', 'Expression' ],
Directive: [],
BlockStatement: [ 'Scopable', 'BlockParent', 'Block', 'Statement' ],
BreakStatement: [ 'Statement', 'Terminatorless', 'CompletionStatement' ],
CallExpression: [ 'Expression' ],
CatchClause: [ 'Scopable' ],
ConditionalExpression: [ 'Expression' ],
ContinueStatement: [ 'Statement', 'Terminatorless', 'CompletionStatement' ],
DebuggerStatement: [ 'Statement' ],
DoWhileStatement: [ 'Statement', 'BlockParent', 'Loop', 'While', 'Scopable' ],
EmptyStatement: [ 'Statement' ],
ExpressionStatement: [ 'Statement' ],
File: [],
ForInStatement:
[ 'Scopable',
'Statement',
'For',
'BlockParent',
'Loop',
'ForXStatement' ],
ForStatement: [ 'Scopable', 'Statement', 'For', 'BlockParent', 'Loop' ],
FunctionDeclaration:
[ 'Scopable',
'Function',
'BlockParent',
'FunctionParent',
'Statement',
'Pure',
'Declaration' ],
FunctionExpression:
[ 'Scopable',
'Function',
'BlockParent',
'FunctionParent',
'Expression',
'Pure' ],
Identifier: [ 'Expression', 'LVal' ],
IfStatement: [ 'Statement' ],
LabeledStatement: [ 'Statement' ],
StringLiteral: [ 'Expression', 'Pure', 'Literal', 'Immutable' ],
NumberLiteral: [ 'Expression', 'Pure', 'Literal', 'Immutable' ],
NullLiteral: [ 'Expression', 'Pure', 'Literal', 'Immutable' ],
BooleanLiteral: [ 'Expression', 'Pure', 'Literal', 'Immutable' ],
RegexLiteral: [ 'Expression', 'Literal' ],
LogicalExpression: [ 'Binary', 'Expression' ],
MemberExpression: [ 'Expression', 'LVal' ],
NewExpression: [ 'Expression' ],
ObjectExpression: [ 'Expression' ],
Program: [ 'Scopable', 'BlockParent', 'Block', 'FunctionParent' ],
Property: [ 'UserWhitespacable' ],
RestElement: [],
ReturnStatement: [ 'Statement', 'Terminatorless', 'CompletionStatement' ],
SequenceExpression: [ 'Expression' ],
SwitchCase: [],
SwitchStatement: [ 'Statement', 'BlockParent', 'Scopable' ],
ThisExpression: [ 'Expression' ],
ThrowStatement: [ 'Statement', 'Terminatorless', 'CompletionStatement' ],
TryStatement: [ 'Statement' ],
UnaryExpression: [ 'UnaryLike', 'Expression' ],
UpdateExpression: [ 'Expression' ],
VariableDeclaration: [ 'Statement', 'Declaration' ],
VariableDeclarator: [],
WhileStatement: [ 'Statement', 'BlockParent', 'Loop', 'While', 'Scopable' ],
WithStatement: [ 'Statement' ],
AssignmentPattern: [ 'Pattern', 'LVal' ],
ArrayPattern: [ 'Pattern', 'LVal' ],
ArrowFunctionExpression:
[ 'Scopable',
'Function',
'BlockParent',
'FunctionParent',
'Expression',
'Pure' ],
ClassBody: [],
ClassDeclaration: [ 'Scopable', 'Class', 'Statement', 'Declaration' ],
ClassExpression: [ 'Scopable', 'Class', 'Expression' ],
ExportAllDeclaration:
[ 'Statement',
'Declaration',
'ModuleDeclaration',
'ExportDeclaration' ],
ExportDefaultDeclaration:
[ 'Statement',
'Declaration',
'ModuleDeclaration',
'ExportDeclaration' ],
ExportNamedDeclaration:
[ 'Statement',
'Declaration',
'ModuleDeclaration',
'ExportDeclaration' ],
ExportSpecifier: [ 'ModuleSpecifier' ],
ForOfStatement:
[ 'Scopable',
'Statement',
'For',
'BlockParent',
'Loop',
'ForXStatement' ],
ImportDeclaration: [ 'Statement', 'Declaration', 'ModuleDeclaration' ],
ImportDefaultSpecifier: [ 'ModuleSpecifier' ],
ImportNamespaceSpecifier: [ 'ModuleSpecifier' ],
ImportSpecifier: [ 'ModuleSpecifier' ],
MetaProperty: [ 'Expression' ],
MethodDefinition: [],
ObjectPattern: [ 'Pattern', 'LVal' ],
SpreadElement: [ 'UnaryLike' ],
Super: [ 'Expression' ],
TaggedTemplateExpression: [ 'Expression' ],
TemplateElement: [],
TemplateLiteral: [ 'Expression', 'Literal' ],
YieldExpression: [ 'Expression', 'Terminatorless' ],
AnyTypeAnnotation: [ 'Flow', 'FlowBaseAnnotation' ],
ArrayTypeAnnotation: [ 'Flow' ],
BooleanTypeAnnotation: [ 'Flow', 'FlowBaseAnnotation' ],
BooleanLiteralTypeAnnotation: [ 'Flow' ],
ClassImplements: [ 'Flow' ],
ClassProperty: [ 'Flow' ],
DeclareClass: [ 'Flow', 'FlowDeclaration', 'Statement', 'Declaration' ],
DeclareFunction: [ 'Flow', 'FlowDeclaration', 'Statement', 'Declaration' ],
DeclareModule: [ 'Flow', 'FlowDeclaration', 'Statement', 'Declaration' ],
DeclareVariable: [ 'Flow', 'FlowDeclaration', 'Statement', 'Declaration' ],
FunctionTypeAnnotation: [ 'Flow' ],
FunctionTypeParam: [ 'Flow' ],
GenericTypeAnnotation: [ 'Flow' ],
InterfaceExtends: [ 'Flow' ],
InterfaceDeclaration: [ 'Flow', 'FlowDeclaration', 'Statement', 'Declaration' ],
IntersectionTypeAnnotation: [ 'Flow' ],
MixedTypeAnnotation: [ 'Flow', 'FlowBaseAnnotation' ],
NullableTypeAnnotation: [ 'Flow' ],
NumberLiteralTypeAnnotation: [ 'Flow' ],
NumberTypeAnnotation: [ 'Flow', 'FlowBaseAnnotation' ],
StringLiteralTypeAnnotation: [ 'Flow' ],
StringTypeAnnotation: [ 'Flow', 'FlowBaseAnnotation' ],
TupleTypeAnnotation: [ 'Flow' ],
TypeofTypeAnnotation: [ 'Flow' ],
TypeAlias: [ 'Flow', 'FlowDeclaration', 'Statement', 'Declaration' ],
TypeAnnotation: [ 'Flow' ],
TypeCastExpression: [ 'Flow' ],
TypeParameterDeclaration: [ 'Flow' ],
TypeParameterInstantiation: [ 'Flow' ],
ObjectTypeAnnotation: [ 'Flow' ],
ObjectTypeCallProperty: [ 'Flow', 'UserWhitespacable' ],
ObjectTypeIndexer: [ 'Flow', 'UserWhitespacable' ],
ObjectTypeProperty: [ 'Flow', 'UserWhitespacable' ],
QualifiedTypeIdentifier: [ 'Flow' ],
UnionTypeAnnotation: [ 'Flow' ],
VoidTypeAnnotation: [ 'Flow', 'FlowBaseAnnotation' ],
JSXAttribute: [ 'JSX', 'Immutable' ],
JSXClosingElement: [ 'JSX', 'Immutable' ],
JSXElement: [ 'JSX', 'Immutable', 'Expression' ],
JSXEmptyExpression: [ 'JSX', 'Expression' ],
JSXExpressionContainer: [ 'JSX', 'Immutable' ],
JSXIdentifier: [ 'JSX', 'Expression' ],
JSXMemberExpression: [ 'JSX', 'Expression' ],
JSXNamespacedName: [ 'JSX' ],
JSXOpeningElement: [ 'JSX', 'Immutable' ],
JSXSpreadAttribute: [ 'JSX' ],
JSXText: [ 'JSX' ],
Noop: [],
ParenthesizedExpression: [ 'Expression' ],
AwaitExpression: [ 'Expression', 'Terminatorless' ],
BindExpression: [],
ComprehensionBlock: [],
ComprehensionExpression: [ 'Expression', 'Scopable' ],
Decorator: [],
DoExpression: [ 'Expression' ],
ExportDefaultSpecifier: [ 'ModuleSpecifier' ],
ExportNamespaceSpecifier: [ 'ModuleSpecifier' ],
RestProperty: [ 'UnaryLike' ],
SpreadProperty: [ 'UnaryLike' ] },
NODE_FIELDS:
{ ArrayExpression: { elements: { validate: [function (node, key, val) ], default: null } },
AssignmentExpression:
{ elements:
{ operator: { validate: [function (node, key, val) ] },
left: { validate: [function (node, key, val) ] },
right: { validate: [function (node, key, val) ] },
default: null },
left: { default: null },
right: { default: null },
operator: { default: null } },
BinaryExpression:
{ operator: { validate: [function (node, key, val) ], default: null },
left: { validate: [function (node, key, val) ], default: null },
right: { validate: [function (node, key, val) ], default: null } },
Directive: { value: { validate: [function (node, key, val) ], default: null } },
BlockStatement:
{ directives: { validate: [function () ], default: [] },
body: { validate: [function () ], default: null } },
BreakStatement:
{ label:
{ validate: [function (node, key, val) ],
optional: true,
default: null } },
CallExpression:
{ callee: { validate: [function (node, key, val) ], default: null },
arguments: { validate: [function (node, key, val) ], default: null } },
CatchClause:
{ param: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
ConditionalExpression:
{ test: { validate: [function (node, key, val) ], default: null },
consequent: { validate: [function (node, key, val) ], default: null },
alternate: { validate: [function (node, key, val) ], default: null } },
ContinueStatement:
{ label:
{ validate: [function (node, key, val) ],
optional: true,
default: null } },
DebuggerStatement: {},
DoWhileStatement:
{ test: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
EmptyStatement: {},
ExpressionStatement: { expression: { validate: [function (node, key, val) ], default: null } },
File:
{ program: { validate: [function (node, key, val) ], default: null },
comments: { default: null },
tokens: { default: null } },
ForInStatement:
{ left: { validate: [function (node, key, val) ], default: null },
right: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
ForStatement:
{ init: { validate: [function (node, key, val) ], default: null },
test: { validate: [function (node, key, val) ], default: null },
update: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
FunctionDeclaration:
{ id: { validate: [function (node, key, val) ], default: null },
params: { validate: [function () ], default: null },
body: { validate: [function (node, key, val) ], default: null },
generator: { default: false, validate: [function (node, key, val) ] },
async: { default: false, validate: [function (node, key, val) ] },
returnType: { default: null },
typeParameters: { default: null } },
FunctionExpression:
{ id:
{ validate: [function (node, key, val) ],
optional: true,
default: null },
params: { validate: [function () ], default: null },
body: { validate: [function (node, key, val) ], default: null },
generator: { default: false, validate: [function (node, key, val) ] },
async: { default: false, validate: [function (node, key, val) ] },
returnType: { default: null },
typeParameters: { default: null } },
Identifier:
{ name:
{ validate: [function validate(node, key, val) ],
default: null },
typeAnnotation: { default: null } },
IfStatement:
{ test: { validate: [function (node, key, val) ], default: null },
consequent:
{ optional: true,
validate: [function (node, key, val) ],
default: null },
alternate:
{ optional: true,
validate: [function (node, key, val) ],
default: null } },
LabeledStatement:
{ label: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
StringLiteral: { value: { validate: [function (node, key, val) ], default: null } },
NumberLiteral: { value: { validate: [function (node, key, val) ], default: null } },
NullLiteral: {},
BooleanLiteral: { value: { validate: [function (node, key, val) ], default: null } },
RegexLiteral:
{ pattern: { validate: [function (node, key, val) ], default: null },
flags: { validate: [function (node, key, val) ], default: '' } },
LogicalExpression:
{ operator: { default: null },
left: { validate: [function (node, key, val) ], default: null },
right: { validate: [function (node, key, val) ], default: null } },
MemberExpression:
{ object: { validate: [function (node, key, val) ], default: null },
property:
{ validate: [function validate(node, key, val) ],
default: null },
computed: { default: false } },
NewExpression:
{ callee: { validate: [function (node, key, val) ], default: null },
arguments: { validate: [function () ], default: null } },
ObjectExpression: { properties: { validate: [function () ], default: null } },
Program:
{ directives: { validate: [function () ], default: [] },
body: { validate: [function () ], default: null } },
Property:
{ kind: { validate: [function () ], default: 'init' },
computed: { validate: [function (node, key, val) ], default: false },
key:
{ validate: [function validate(node, key, val) ],
default: null },
value:
{ validate: [function validate(node, key, val) ],
default: null },
method: { validate: [function (node, key, val) ], default: false },
shorthand: { validate: [function (node, key, val) ], default: false },
decorators: { validate: [function () ], default: null } },
RestElement:
{ argument: { validate: [function (node, key, val) ], default: null },
typeAnnotation: { default: null } },
ReturnStatement: { argument: { validate: [function (node, key, val) ], default: null } },
SequenceExpression: { expressions: { validate: [function (node, key, val) ], default: null } },
SwitchCase: { test: { default: null }, consequent: { default: null } },
SwitchStatement: { discriminant: { default: null }, cases: { default: null } },
ThisExpression: {},
ThrowStatement: { argument: { validate: [function (node, key, val) ], default: null } },
TryStatement:
{ body: { validate: [function (node, key, val) ], default: null },
handler:
{ optional: true,
handler: [function (node, key, val) ],
default: null },
finalizer:
{ optional: true,
validate: [function (node, key, val) ],
default: null },
block: { default: null } },
UnaryExpression:
{ prefix: { default: false },
argument: { validate: [function (node, key, val) ], default: null },
operator: { default: null } },
UpdateExpression:
{ prefix: { default: false },
argument: { validate: [function (node, key, val) ], default: null },
operator: { default: null } },
VariableDeclaration:
{ kind: { validate: [function () ], default: null },
declarations: { validate: [function () ], default: null } },
VariableDeclarator:
{ id: { validate: [function (node, key, val) ], default: null },
init:
{ optional: true,
validate: [function (node, key, val) ],
default: null } },
WhileStatement:
{ test: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
WithStatement:
{ object: { object: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
AssignmentPattern:
{ left: { validate: [function (node, key, val) ], default: null },
right: { validate: [function (node, key, val) ], default: null } },
ArrayPattern:
{ elements: { validate: [function () ], default: null },
typeAnnotation: { default: null } },
ArrowFunctionExpression:
{ params: { validate: [function () ], default: null },
body: { validate: [function (node, key, val) ], default: null },
async: { validate: [function (node, key, val) ], default: false },
returnType: { default: null } },
ClassBody: { body: { validate: [function () ], default: null } },
ClassDeclaration:
{ id: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null },
superClass:
{ optional: true,
validate: [function (node, key, val) ],
default: null },
decorators: { validate: [function () ], default: null },
typeParameters: { default: null },
superTypeParameters: { default: null },
implements: { default: null } },
ClassExpression:
{ id:
{ optional: true,
validate: [function (node, key, val) ],
default: null },
body: { validate: [function (node, key, val) ], default: null },
superClass:
{ optional: true,
validate: [function (node, key, val) ],
default: null },
decorators: { validate: [function () ], default: null },
typeParameters: { default: null },
superTypeParameters: { default: null },
implements: { default: null } },
ExportAllDeclaration: { source: { default: null }, exported: { default: null } },
ExportDefaultDeclaration: { declaration: { default: null } },
ExportNamedDeclaration:
{ declaration: { default: null },
specifiers: { default: null },
source: { default: null } },
ExportSpecifier:
{ local: { validate: [function (node, key, val) ], default: null },
imported: { validate: [function (node, key, val) ], default: null },
exported: { default: null } },
ForOfStatement:
{ left: { validate: [function (node, key, val) ], default: null },
right: { validate: [function (node, key, val) ], default: null },
body: { validate: [function (node, key, val) ], default: null } },
ImportDeclaration:
{ specifiers: { default: null },
source: { validate: [function (node, key, val) ], default: null } },
ImportDefaultSpecifier: { local: { validate: [function (node, key, val) ], default: null } },
ImportNamespaceSpecifier: { local: { validate: [function (node, key, val) ], default: null } },
ImportSpecifier:
{ local: { validate: [function (node, key, val) ], default: null },
imported: { validate: [function (node, key, val) ], default: null } },
MetaProperty:
{ meta: { validate: [function (node, key, val) ], default: null },
property: { validate: [function (node, key, val) ], default: null } },
MethodDefinition:
{ kind: { validate: [function () ], default: 'method' },
computed: { default: false, validate: [function (node, key, val) ] },
static: { default: false, validate: [function (node, key, val) ] },
key: { default: null },
value: { default: null },
decorators: { default: null } },
ObjectPattern:
{ properties: { validate: [function () ], default: null },
typeAnnotation: { default: null } },
SpreadElement: { argument: { validate: [function (node, key, val) ], default: null } },
Super: {},
TaggedTemplateExpression:
{ tag: { validate: [function (node, key, val) ], default: null },
quasi: { validate: [function (node, key, val) ], default: null } },
TemplateElement:
{ value: { default: null },
tail: { validate: [function (node, key, val) ], default: false } },
TemplateLiteral: { quasis: { default: null }, expressions: { default: null } },
YieldExpression:
{ delegate: { validate: [function (node, key, val) ], default: false },
argument:
{ optional: true,
validate: [function (node, key, val) ],
default: null } },
AnyTypeAnnotation: {},
ArrayTypeAnnotation: { elementType: { default: null } },
BooleanTypeAnnotation: {},
BooleanLiteralTypeAnnotation: {},
ClassImplements: { id: { default: null }, typeParameters: { default: null } },
ClassProperty:
{ key: { default: null },
value: { default: null },
typeAnnotation: { default: null },
decorators: { default: null } },
DeclareClass:
{ id: { default: null },
typeParameters: { default: null },
extends: { default: null },
body: { default: null } },
DeclareFunction: { id: { default: null } },
DeclareModule: { id: { default: null }, body: { default: null } },
DeclareVariable: { id: { default: null } },
FunctionTypeAnnotation:
{ typeParameters: { default: null },
params: { default: null },
rest: { default: null },
returnType: { default: null } },
FunctionTypeParam: { name: { default: null }, typeAnnotation: { default: null } },
GenericTypeAnnotation: { id: { default: null }, typeParameters: { default: null } },
InterfaceExtends: { id: { default: null }, typeParameters: { default: null } },
InterfaceDeclaration:
{ id: { default: null },
typeParameters: { default: null },
extends: { default: null },
body: { default: null } },
IntersectionTypeAnnotation: { types: { default: null } },
MixedTypeAnnotation: {},
NullableTypeAnnotation: { typeAnnotation: { default: null } },
NumberLiteralTypeAnnotation: {},
NumberTypeAnnotation: {},
StringLiteralTypeAnnotation: {},
StringTypeAnnotation: {},
TupleTypeAnnotation: { types: { default: null } },
TypeofTypeAnnotation: { argument: { default: null } },
TypeAlias:
{ id: { default: null },
typeParameters: { default: null },
right: { default: null } },
TypeAnnotation: { typeAnnotation: { default: null } },
TypeCastExpression:
{ expression: { default: null },
typeAnnotation: { default: null } },
TypeParameterDeclaration: { params: { default: null } },
TypeParameterInstantiation: { params: { default: null } },
ObjectTypeAnnotation:
{ properties: { default: null },
indexers: { default: null },
callProperties: { default: null } },
ObjectTypeCallProperty: { value: { default: null } },
ObjectTypeIndexer:
{ id: { default: null },
key: { default: null },
value: { default: null } },
ObjectTypeProperty: { key: { default: null }, value: { default: null } },
QualifiedTypeIdentifier: { id: { default: null }, qualification: { default: null } },
UnionTypeAnnotation: { types: { default: null } },
VoidTypeAnnotation: {},
JSXAttribute:
{ name: { validate: [function (node, key, val) ], default: null },
value:
{ optional: true,
validate: [function (node, key, val) ],
default: null } },
JSXClosingElement: { name: { validate: [function (node, key, val) ], default: null } },
JSXElement:
{ openingElement: { validate: [function (node, key, val) ], default: null },
closingElement:
{ optional: true,
validate: [function (node, key, val) ],
default: null },
children: { default: null },
selfClosing: { default: null } },
JSXEmptyExpression: {},
JSXExpressionContainer: { expression: { validate: [function (node, key, val) ], default: null } },
JSXIdentifier: { name: { default: null } },
JSXMemberExpression:
{ object: { validate: [function (node, key, val) ], default: null },
property: { validate: [function (node, key, val) ], default: null } },
JSXNamespacedName:
{ namespace: { validate: [function (node, key, val) ], default: null },
name: { validate: [function (node, key, val) ], default: null } },
JSXOpeningElement:
{ name: { validate: [function (node, key, val) ], default: null },
selfClosing: { default: false, validate: [function (node, key, val) ] },
attributes: { validate: [function () ], default: null } },
JSXSpreadAttribute: { argument: { validate: [function (node, key, val) ], default: null } },
JSXText: { value: { validate: [function (node, key, val) ], default: null } },
Noop: {},
ParenthesizedExpression: { expression: { validate: [function (node, key, val) ], default: null } },
AwaitExpression:
{ all: { validate: [function (node, key, val) ], default: false },
argument: { validate: [function (node, key, val) ], default: null } },
BindExpression: { object: { default: null }, callee: { default: null } },
ComprehensionBlock: { left: { default: null }, right: { default: null } },
ComprehensionExpression:
{ filter: { default: null },
blocks: { default: null },
body: { default: null } },
Decorator: { expression: { validate: [function (node, key, val) ], default: null } },
DoExpression: { body: { validate: [function (node, key, val) ], default: null } },
ExportDefaultSpecifier: { exported: { validate: [function (node, key, val) ], default: null } },
ExportNamespaceSpecifier: { exported: { validate: [function (node, key, val) ], default: null } },
RestProperty: { argument: { validate: [function (node, key, val) ], default: null } },
SpreadProperty: { argument: { validate: [function (node, key, val) ], default: null } } },
BUILDER_KEYS:
{ ArrayExpression: [ 'elements' ],
AssignmentExpression: [ 'operator', 'left', 'right' ],
BinaryExpression: [ 'operator', 'left', 'right' ],
Directive: [],
BlockStatement: [ 'body', 'directives' ],
BreakStatement: [ 'label' ],
CallExpression: [ 'callee', 'arguments' ],
CatchClause: [ 'param', 'body' ],
ConditionalExpression: [ 'test', 'consequent', 'alternate' ],
ContinueStatement: [ 'label' ],
DebuggerStatement: [],
DoWhileStatement: [ 'test', 'body' ],
EmptyStatement: [],
ExpressionStatement: [ 'expression' ],
File: [ 'program', 'comments', 'tokens' ],
ForInStatement: [ 'left', 'right', 'body' ],
ForStatement: [ 'init', 'test', 'update', 'body' ],
FunctionDeclaration: [ 'id', 'params', 'body', 'generator', 'async' ],
FunctionExpression: [ 'id', 'params', 'body', 'generator', 'async' ],
Identifier: [ 'name' ],
IfStatement: [ 'test', 'consequent', 'alternate' ],
LabeledStatement: [ 'label', 'body' ],
StringLiteral: [ 'value' ],
NumberLiteral: [ 'value' ],
NullLiteral: [],
BooleanLiteral: [ 'value' ],
RegexLiteral: [ 'pattern', 'flags' ],
LogicalExpression: [ 'operator', 'left', 'right' ],
MemberExpression: [ 'object', 'property', 'computed' ],
NewExpression: [ 'callee', 'arguments' ],
ObjectExpression: [ 'properties' ],
Program: [ 'body', 'directives' ],
Property: [ 'kind', 'key', 'value', 'computed', 'method', 'shorthand' ],
RestElement: [ 'argument', 'typeAnnotation' ],
ReturnStatement: [ 'argument' ],
SequenceExpression: [ 'expressions' ],
SwitchCase: [ 'test', 'consequent' ],
SwitchStatement: [ 'discriminant', 'cases' ],
ThisExpression: [],
ThrowStatement: [ 'argument' ],
TryStatement: [ 'block', 'handler', 'finalizer' ],
UnaryExpression: [ 'operator', 'argument', 'prefix' ],
UpdateExpression: [ 'operator', 'argument', 'prefix' ],
VariableDeclaration: [ 'kind', 'declarations' ],
VariableDeclarator: [ 'id', 'init' ],
WhileStatement: [ 'test', 'body' ],
WithStatement: [ 'object', 'body' ],
AssignmentPattern: [ 'left', 'right' ],
ArrayPattern: [ 'elements', 'typeAnnotation' ],
ArrowFunctionExpression: [ 'params', 'body', 'async' ],
ClassBody: [ 'body' ],
ClassDeclaration: [ 'id', 'superClass', 'body', 'decorators' ],
ClassExpression: [ 'id', 'superClass', 'body', 'decorators' ],
ExportAllDeclaration: [ 'source', 'exported' ],
ExportDefaultDeclaration: [ 'declaration' ],
ExportNamedDeclaration: [ 'declaration', 'specifiers', 'source' ],
ExportSpecifier: [ 'local', 'exported' ],
ForOfStatement: [ 'left', 'right', 'body' ],
ImportDeclaration: [ 'specifiers', 'source' ],
ImportDefaultSpecifier: [ 'local' ],
ImportNamespaceSpecifier: [ 'local' ],
ImportSpecifier: [ 'local', 'imported' ],
MetaProperty: [ 'meta', 'property' ],
MethodDefinition: [ 'key', 'value', 'kind', 'computed', 'static' ],
ObjectPattern: [ 'properties', 'typeAnnotation' ],
SpreadElement: [ 'argument' ],
Super: [],
TaggedTemplateExpression: [ 'tag', 'quasi' ],
TemplateElement: [ 'value', 'tail' ],
TemplateLiteral: [ 'quasis', 'expressions' ],
YieldExpression: [ 'argument', 'delegate' ],
AnyTypeAnnotation: [],
ArrayTypeAnnotation: [ 'elementType' ],
BooleanTypeAnnotation: [],
BooleanLiteralTypeAnnotation: [],
ClassImplements: [ 'id', 'typeParameters' ],
ClassProperty: [ 'key', 'value', 'typeAnnotation', 'decorators' ],
DeclareClass: [ 'id', 'typeParameters', 'extends', 'body' ],
DeclareFunction: [ 'id' ],
DeclareModule: [ 'id', 'body' ],
DeclareVariable: [ 'id' ],
FunctionTypeAnnotation: [ 'typeParameters', 'params', 'rest', 'returnType' ],
FunctionTypeParam: [ 'name', 'typeAnnotation' ],
GenericTypeAnnotation: [ 'id', 'typeParameters' ],
InterfaceExtends: [ 'id', 'typeParameters' ],
InterfaceDeclaration: [ 'id', 'typeParameters', 'extends', 'body' ],
IntersectionTypeAnnotation: [ 'types' ],
MixedTypeAnnotation: [],
NullableTypeAnnotation: [ 'typeAnnotation' ],
NumberLiteralTypeAnnotation: [],
NumberTypeAnnotation: [],
StringLiteralTypeAnnotation: [],
StringTypeAnnotation: [],
TupleTypeAnnotation: [ 'types' ],
TypeofTypeAnnotation: [ 'argument' ],
TypeAlias: [ 'id', 'typeParameters', 'right' ],
TypeAnnotation: [ 'typeAnnotation' ],
TypeCastExpression: [ 'expression', 'typeAnnotation' ],
TypeParameterDeclaration: [ 'params' ],
TypeParameterInstantiation: [ 'params' ],
ObjectTypeAnnotation: [ 'properties', 'indexers', 'callProperties' ],
ObjectTypeCallProperty: [ 'value' ],
ObjectTypeIndexer: [ 'id', 'key', 'value' ],
ObjectTypeProperty: [ 'key', 'value' ],
QualifiedTypeIdentifier: [ 'id', 'qualification' ],
UnionTypeAnnotation: [ 'types' ],
VoidTypeAnnotation: [],
JSXAttribute: [ 'name', 'value' ],
JSXClosingElement: [ 'name' ],
JSXElement: [ 'openingElement', 'closingElement', 'children', 'selfClosing' ],
JSXEmptyExpression: [],
JSXExpressionContainer: [ 'expression' ],
JSXIdentifier: [ 'name' ],
JSXMemberExpression: [ 'object', 'property' ],
JSXNamespacedName: [ 'namespace', 'name' ],
JSXOpeningElement: [ 'name', 'attributes', 'selfClosing' ],
JSXSpreadAttribute: [ 'argument' ],
JSXText: [ 'value' ],
Noop: [],
ParenthesizedExpression: [ 'expression' ],
AwaitExpression: [ 'argument', 'all' ],
BindExpression: [ 'object', 'callee' ],
ComprehensionBlock: [ 'left', 'right' ],
ComprehensionExpression: [ 'filter', 'blocks', 'body' ],
Decorator: [ 'expression' ],
DoExpression: [ 'body' ],
ExportDefaultSpecifier: [ 'exported' ],
ExportNamespaceSpecifier: [ 'exported' ],
RestProperty: [ 'argument' ],
SpreadProperty: [ 'argument' ] },
react:
{ __esModule: true,
isCompatTag: [function isCompatTag(tagName) ],
buildChildren: [function buildChildren(node) ],
isReactComponent: [function (member) ] },
isArrayExpression: [function (node, opts) ],
assertArrayExpression: [function (node, opts) ],
isAssignmentExpression: [function (node, opts) ],
assertAssignmentExpression: [function (node, opts) ],
isBinaryExpression: [function (node, opts) ],
assertBinaryExpression: [function (node, opts) ],
isDirective: [function (node, opts) ],
assertDirective: [function (node, opts) ],
isBlockStatement: [function (node, opts) ],
assertBlockStatement: [function (node, opts) ],
isBreakStatement: [function (node, opts) ],
assertBreakStatement: [function (node, opts) ],
isCallExpression: [function (node, opts) ],
assertCallExpression: [function (node, opts) ],
isCatchClause: [function (node, opts) ],
assertCatchClause: [function (node, opts) ],
isConditionalExpression: [function (node, opts) ],
assertConditionalExpression: [function (node, opts) ],
isContinueStatement: [function (node, opts) ],
assertContinueStatement: [function (node, opts) ],
isDebuggerStatement: [function (node, opts) ],
assertDebuggerStatement: [function (node, opts) ],
isDoWhileStatement: [function (node, opts) ],
assertDoWhileStatement: [function (node, opts) ],
isEmptyStatement: [function (node, opts) ],
assertEmptyStatement: [function (node, opts) ],
isExpressionStatement: [function (node, opts) ],
assertExpressionStatement: [function (node, opts) ],
isFile: [function (node, opts) ],
assertFile: [function (node, opts) ],
isForInStatement: [function (node, opts) ],
assertForInStatement: [function (node, opts) ],
isForStatement: [function (node, opts) ],
assertForStatement: [function (node, opts) ],
isFunctionDeclaration: [function (node, opts) ],
assertFunctionDeclaration: [function (node, opts) ],
isFunctionExpression: [function (node, opts) ],
assertFunctionExpression: [function (node, opts) ],
isIdentifier: [function (node, opts) ],
assertIdentifier: [function (node, opts) ],
isIfStatement: [function (node, opts) ],
assertIfStatement: [function (node, opts) ],
isLabeledStatement: [function (node, opts) ],
assertLabeledStatement: [function (node, opts) ],
isStringLiteral: [function (node, opts) ],
assertStringLiteral: [function (node, opts) ],
isNumberLiteral: [function (node, opts) ],
assertNumberLiteral: [function (node, opts) ],
isNullLiteral: [function (node, opts) ],
assertNullLiteral: [function (node, opts) ],
isBooleanLiteral: [function (node, opts) ],
assertBooleanLiteral: [function (node, opts) ],
isRegexLiteral: [function (node, opts) ],
assertRegexLiteral: [function (node, opts) ],
isLogicalExpression: [function (node, opts) ],
assertLogicalExpression: [function (node, opts) ],
isMemberExpression: [function (node, opts) ],
assertMemberExpression: [function (node, opts) ],
isNewExpression: [function (node, opts) ],
assertNewExpression: [function (node, opts) ],
isObjectExpression: [function (node, opts) ],
assertObjectExpression: [function (node, opts) ],
isProgram: [function (node, opts) ],
assertProgram: [function (node, opts) ],
isProperty: [function (node, opts) ],
assertProperty: [function (node, opts) ],
isRestElement: [function (node, opts) ],
assertRestElement: [function (node, opts) ],
isReturnStatement: [function (node, opts) ],
assertReturnStatement: [function (node, opts) ],
isSequenceExpression: [function (node, opts) ],
assertSequenceExpression: [function (node, opts) ],
isSwitchCase: [function (node, opts) ],
assertSwitchCase: [function (node, opts) ],
isSwitchStatement: [function (node, opts) ],
assertSwitchStatement: [function (node, opts) ],
isThisExpression: [function (node, opts) ],
assertThisExpression: [function (node, opts) ],
isThrowStatement: [function (node, opts) ],
assertThrowStatement: [function (node, opts) ],
isTryStatement: [function (node, opts) ],
assertTryStatement: [function (node, opts) ],
isUnaryExpression: [function (node, opts) ],
assertUnaryExpression: [function (node, opts) ],
isUpdateExpression: [function (node, opts) ],
assertUpdateExpression: [function (node, opts) ],
isVariableDeclaration: [function (node, opts) ],
assertVariableDeclaration: [function (node, opts) ],
isVariableDeclarator: [function (node, opts) ],
assertVariableDeclarator: [function (node, opts) ],
isWhileStatement: [function (node, opts) ],
assertWhileStatement: [function (node, opts) ],
isWithStatement: [function (node, opts) ],
assertWithStatement: [function (node, opts) ],
isAssignmentPattern: [function (node, opts) ],
assertAssignmentPattern: [function (node, opts) ],
isArrayPattern: [function (node, opts) ],
assertArrayPattern: [function (node, opts) ],
isArrowFunctionExpression: [function (node, opts) ],
assertArrowFunctionExpression: [function (node, opts) ],
isClassBody: [function (node, opts) ],
assertClassBody: [function (node, opts) ],
isClassDeclaration: [function (node, opts) ],
assertClassDeclaration: [function (node, opts) ],
isClassExpression: [function (node, opts) ],
assertClassExpression: [function (node, opts) ],
isExportAllDeclaration: [function (node, opts) ],
assertExportAllDeclaration: [function (node, opts) ],
isExportDefaultDeclaration: [function (node, opts) ],
assertExportDefaultDeclaration: [function (node, opts) ],
isExportNamedDeclaration: [function (node, opts) ],
assertExportNamedDeclaration: [function (node, opts) ],
isExportSpecifier: [function (node, opts) ],
assertExportSpecifier: [function (node, opts) ],
isForOfStatement: [function (node, opts) ],
assertForOfStatement: [function (node, opts) ],
isImportDeclaration: [function (node, opts) ],
assertImportDeclaration: [function (node, opts) ],
isImportDefaultSpecifier: [function (node, opts) ],
assertImportDefaultSpecifier: [function (node, opts) ],
isImportNamespaceSpecifier: [function (node, opts) ],
assertImportNamespaceSpecifier: [function (node, opts) ],
isImportSpecifier: [function (node, opts) ],
assertImportSpecifier: [function (node, opts) ],
isMetaProperty: [function (node, opts) ],
assertMetaProperty: [function (node, opts) ],
isMethodDefinition: [function (node, opts) ],
assertMethodDefinition: [function (node, opts) ],
isObjectPattern: [function (node, opts) ],
assertObjectPattern: [function (node, opts) ],
isSpreadElement: [function (node, opts) ],
assertSpreadElement: [function (node, opts) ],
isSuper: [function (node, opts) ],
assertSuper: [function (node, opts) ],
isTaggedTemplateExpression: [function (node, opts) ],
assertTaggedTemplateExpression: [function (node, opts) ],
isTemplateElement: [function (node, opts) ],
assertTemplateElement: [function (node, opts) ],
isTemplateLiteral: [function (node, opts) ],
assertTemplateLiteral: [function (node, opts) ],
isYieldExpression: [function (node, opts) ],
assertYieldExpression: [function (node, opts) ],
isAnyTypeAnnotation: [function (node, opts) ],
assertAnyTypeAnnotation: [function (node, opts) ],
isArrayTypeAnnotation: [function (node, opts) ],
assertArrayTypeAnnotation: [function (node, opts) ],
isBooleanTypeAnnotation: [function (node, opts) ],
assertBooleanTypeAnnotation: [function (node, opts) ],
isBooleanLiteralTypeAnnotation: [function (node, opts) ],
assertBooleanLiteralTypeAnnotation: [function (node, opts) ],
isClassImplements: [function (node, opts) ],
assertClassImplements: [function (node, opts) ],
isClassProperty: [function (node, opts) ],
assertClassProperty: [function (node, opts) ],
isDeclareClass: [function (node, opts) ],
assertDeclareClass: [function (node, opts) ],
isDeclareFunction: [function (node, opts) ],
assertDeclareFunction: [function (node, opts) ],
isDeclareModule: [function (node, opts) ],
assertDeclareModule: [function (node, opts) ],
isDeclareVariable: [function (node, opts) ],
assertDeclareVariable: [function (node, opts) ],
isFunctionTypeAnnotation: [function (node, opts) ],
assertFunctionTypeAnnotation: [function (node, opts) ],
isFunctionTypeParam: [function (node, opts) ],
assertFunctionTypeParam: [function (node, opts) ],
isGenericTypeAnnotation: [function (node, opts) ],
assertGenericTypeAnnotation: [function (node, opts) ],
isInterfaceExtends: [function (node, opts) ],
assertInterfaceExtends: [function (node, opts) ],
isInterfaceDeclaration: [function (node, opts) ],
assertInterfaceDeclaration: [function (node, opts) ],
isIntersectionTypeAnnotation: [function (node, opts) ],
assertIntersectionTypeAnnotation: [function (node, opts) ],
isMixedTypeAnnotation: [function (node, opts) ],
assertMixedTypeAnnotation: [function (node, opts) ],
isNullableTypeAnnotation: [function (node, opts) ],
assertNullableTypeAnnotation: [function (node, opts) ],
isNumberLiteralTypeAnnotation: [function (node, opts) ],
assertNumberLiteralTypeAnnotation: [function (node, opts) ],
isNumberTypeAnnotation: [function (node, opts) ],
assertNumberTypeAnnotation: [function (node, opts) ],
isStringLiteralTypeAnnotation: [function (node, opts) ],
assertStringLiteralTypeAnnotation: [function (node, opts) ],
isStringTypeAnnotation: [function (node, opts) ],
assertStringTypeAnnotation: [function (node, opts) ],
isTupleTypeAnnotation: [function (node, opts) ],
assertTupleTypeAnnotation: [function (node, opts) ],
isTypeofTypeAnnotation: [function (node, opts) ],
assertTypeofTypeAnnotation: [function (node, opts) ],
isTypeAlias: [function (node, opts) ],
assertTypeAlias: [function (node, opts) ],
isTypeAnnotation: [function (node, opts) ],
assertTypeAnnotation: [function (node, opts) ],
isTypeCastExpression: [function (node, opts) ],
assertTypeCastExpression: [function (node, opts) ],
isTypeParameterDeclaration: [function (node, opts) ],
assertTypeParameterDeclaration: [function (node, opts) ],
isTypeParameterInstantiation: [function (node, opts) ],
assertTypeParameterInstantiation: [function (node, opts) ],
isObjectTypeAnnotation: [function (node, opts) ],
assertObjectTypeAnnotation: [function (node, opts) ],
isObjectTypeCallProperty: [function (node, opts) ],
assertObjectTypeCallProperty: [function (node, opts) ],
isObjectTypeIndexer: [function (node, opts) ],
assertObjectTypeIndexer: [function (node, opts) ],
isObjectTypeProperty: [function (node, opts) ],
assertObjectTypeProperty: [function (node, opts) ],
isQualifiedTypeIdentifier: [function (node, opts) ],
assertQualifiedTypeIdentifier: [function (node, opts) ],
isUnionTypeAnnotation: [function (node, opts) ],
assertUnionTypeAnnotation: [function (node, opts) ],
isVoidTypeAnnotation: [function (node, opts) ],
assertVoidTypeAnnotation: [function (node, opts) ],
isJSXAttribute: [function (node, opts) ],
assertJSXAttribute: [function (node, opts) ],
isJSXClosingElement: [function (node, opts) ],
assertJSXClosingElement: [function (node, opts) ],
isJSXElement: [function (node, opts) ],
assertJSXElement: [function (node, opts) ],
isJSXEmptyExpression: [function (node, opts) ],
assertJSXEmptyExpression: [function (node, opts) ],
isJSXExpressionContainer: [function (node, opts) ],
assertJSXExpressionContainer: [function (node, opts) ],
isJSXIdentifier: [function (node, opts) ],
assertJSXIdentifier: [function (node, opts) ],
isJSXMemberExpression: [function (node, opts) ],
assertJSXMemberExpression: [function (node, opts) ],
isJSXNamespacedName: [function (node, opts) ],
assertJSXNamespacedName: [function (node, opts) ],
isJSXOpeningElement: [function (node, opts) ],
assertJSXOpeningElement: [function (node, opts) ],
isJSXSpreadAttribute: [function (node, opts) ],
assertJSXSpreadAttribute: [function (node, opts) ],
isJSXText: [function (node, opts) ],
assertJSXText: [function (node, opts) ],
isNoop: [function (node, opts) ],
assertNoop: [function (node, opts) ],
isParenthesizedExpression: [function (node, opts) ],
assertParenthesizedExpression: [function (node, opts) ],
isAwaitExpression: [function (node, opts) ],
assertAwaitExpression: [function (node, opts) ],
isBindExpression: [function (node, opts) ],
assertBindExpression: [function (node, opts) ],
isComprehensionBlock: [function (node, opts) ],
assertComprehensionBlock: [function (node, opts) ],
isComprehensionExpression: [function (node, opts) ],
assertComprehensionExpression: [function (node, opts) ],
isDecorator: [function (node, opts) ],
assertDecorator: [function (node, opts) ],
isDoExpression: [function (node, opts) ],
assertDoExpression: [function (node, opts) ],
isExportDefaultSpecifier: [function (node, opts) ],
assertExportDefaultSpecifier: [function (node, opts) ],
isExportNamespaceSpecifier: [function (node, opts) ],
assertExportNamespaceSpecifier: [function (node, opts) ],
isRestProperty: [function (node, opts) ],
assertRestProperty: [function (node, opts) ],
isSpreadProperty: [function (node, opts) ],
assertSpreadProperty: [function (node, opts) ],
FLIPPED_ALIAS_KEYS:
{ Expression:
[ 'ArrayExpression',
'AssignmentExpression',
'BinaryExpression',
'CallExpression',
'ConditionalExpression',
'FunctionExpression',
'Identifier',
'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'RegexLiteral',
'LogicalExpression',
'MemberExpression',
'NewExpression',
'ObjectExpression',
'SequenceExpression',
'ThisExpression',
'UnaryExpression',
'UpdateExpression',
'ArrowFunctionExpression',
'ClassExpression',
'MetaProperty',
'Super',
'TaggedTemplateExpression',
'TemplateLiteral',
'YieldExpression',
'JSXElement',
'JSXEmptyExpression',
'JSXIdentifier',
'JSXMemberExpression',
'ParenthesizedExpression',
'AwaitExpression',
'ComprehensionExpression',
'DoExpression' ],
Binary: [ 'BinaryExpression', 'LogicalExpression' ],
Scopable:
[ 'BlockStatement',
'CatchClause',
'DoWhileStatement',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'FunctionExpression',
'Program',
'SwitchStatement',
'WhileStatement',
'ArrowFunctionExpression',
'ClassDeclaration',
'ClassExpression',
'ForOfStatement',
'ComprehensionExpression' ],
BlockParent:
[ 'BlockStatement',
'DoWhileStatement',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'FunctionExpression',
'Program',
'SwitchStatement',
'WhileStatement',
'ArrowFunctionExpression',
'ForOfStatement' ],
Block: [ 'BlockStatement', 'Program' ],
Statement:
[ 'BlockStatement',
'BreakStatement',
'ContinueStatement',
'DebuggerStatement',
'DoWhileStatement',
'EmptyStatement',
'ExpressionStatement',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'IfStatement',
'LabeledStatement',
'ReturnStatement',
'SwitchStatement',
'ThrowStatement',
'TryStatement',
'VariableDeclaration',
'WhileStatement',
'WithStatement',
'ClassDeclaration',
'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ForOfStatement',
'ImportDeclaration',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'InterfaceDeclaration',
'TypeAlias' ],
Terminatorless:
[ 'BreakStatement',
'ContinueStatement',
'ReturnStatement',
'ThrowStatement',
'YieldExpression',
'AwaitExpression' ],
CompletionStatement:
[ 'BreakStatement',
'ContinueStatement',
'ReturnStatement',
'ThrowStatement' ],
Loop:
[ 'DoWhileStatement',
'ForInStatement',
'ForStatement',
'WhileStatement',
'ForOfStatement' ],
While: [ 'DoWhileStatement', 'WhileStatement' ],
For: [ 'ForInStatement', 'ForStatement', 'ForOfStatement' ],
ForXStatement: [ 'ForInStatement', 'ForOfStatement' ],
Function:
[ 'FunctionDeclaration',
'FunctionExpression',
'ArrowFunctionExpression' ],
FunctionParent:
[ 'FunctionDeclaration',
'FunctionExpression',
'Program',
'ArrowFunctionExpression' ],
Pure:
[ 'FunctionDeclaration',
'FunctionExpression',
'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'ArrowFunctionExpression' ],
Declaration:
[ 'FunctionDeclaration',
'VariableDeclaration',
'ClassDeclaration',
'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ImportDeclaration',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'InterfaceDeclaration',
'TypeAlias' ],
LVal:
[ 'Identifier',
'MemberExpression',
'AssignmentPattern',
'ArrayPattern',
'ObjectPattern' ],
Literal:
[ 'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'RegexLiteral',
'TemplateLiteral' ],
Immutable:
[ 'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'JSXAttribute',
'JSXClosingElement',
'JSXElement',
'JSXExpressionContainer',
'JSXOpeningElement' ],
UserWhitespacable:
[ 'Property',
'ObjectTypeCallProperty',
'ObjectTypeIndexer',
'ObjectTypeProperty' ],
UnaryLike:
[ 'UnaryExpression',
'SpreadElement',
'RestProperty',
'SpreadProperty' ],
Pattern: [ 'AssignmentPattern', 'ArrayPattern', 'ObjectPattern' ],
Class: [ 'ClassDeclaration', 'ClassExpression' ],
ModuleDeclaration:
[ 'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ImportDeclaration' ],
ExportDeclaration:
[ 'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration' ],
ModuleSpecifier:
[ 'ExportSpecifier',
'ImportDefaultSpecifier',
'ImportNamespaceSpecifier',
'ImportSpecifier',
'ExportDefaultSpecifier',
'ExportNamespaceSpecifier' ],
Flow:
[ 'AnyTypeAnnotation',
'ArrayTypeAnnotation',
'BooleanTypeAnnotation',
'BooleanLiteralTypeAnnotation',
'ClassImplements',
'ClassProperty',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'FunctionTypeAnnotation',
'FunctionTypeParam',
'GenericTypeAnnotation',
'InterfaceExtends',
'InterfaceDeclaration',
'IntersectionTypeAnnotation',
'MixedTypeAnnotation',
'NullableTypeAnnotation',
'NumberLiteralTypeAnnotation',
'NumberTypeAnnotation',
'StringLiteralTypeAnnotation',
'StringTypeAnnotation',
'TupleTypeAnnotation',
'TypeofTypeAnnotation',
'TypeAlias',
'TypeAnnotation',
'TypeCastExpression',
'TypeParameterDeclaration',
'TypeParameterInstantiation',
'ObjectTypeAnnotation',
'ObjectTypeCallProperty',
'ObjectTypeIndexer',
'ObjectTypeProperty',
'QualifiedTypeIdentifier',
'UnionTypeAnnotation',
'VoidTypeAnnotation' ],
FlowBaseAnnotation:
[ 'AnyTypeAnnotation',
'BooleanTypeAnnotation',
'MixedTypeAnnotation',
'NumberTypeAnnotation',
'StringTypeAnnotation',
'VoidTypeAnnotation' ],
FlowDeclaration:
[ 'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'InterfaceDeclaration',
'TypeAlias' ],
JSX:
[ 'JSXAttribute',
'JSXClosingElement',
'JSXElement',
'JSXEmptyExpression',
'JSXExpressionContainer',
'JSXIdentifier',
'JSXMemberExpression',
'JSXNamespacedName',
'JSXOpeningElement',
'JSXSpreadAttribute',
'JSXText' ] },
EXPRESSION_TYPES:
[ 'ArrayExpression',
'AssignmentExpression',
'BinaryExpression',
'CallExpression',
'ConditionalExpression',
'FunctionExpression',
'Identifier',
'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'RegexLiteral',
'LogicalExpression',
'MemberExpression',
'NewExpression',
'ObjectExpression',
'SequenceExpression',
'ThisExpression',
'UnaryExpression',
'UpdateExpression',
'ArrowFunctionExpression',
'ClassExpression',
'MetaProperty',
'Super',
'TaggedTemplateExpression',
'TemplateLiteral',
'YieldExpression',
'JSXElement',
'JSXEmptyExpression',
'JSXIdentifier',
'JSXMemberExpression',
'ParenthesizedExpression',
'AwaitExpression',
'ComprehensionExpression',
'DoExpression' ],
isExpression: [function (node, opts) ],
assertExpression: [function (node, opts) ],
BINARY_TYPES: [ 'BinaryExpression', 'LogicalExpression' ],
isBinary: [function (node, opts) ],
assertBinary: [function (node, opts) ],
SCOPABLE_TYPES:
[ 'BlockStatement',
'CatchClause',
'DoWhileStatement',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'FunctionExpression',
'Program',
'SwitchStatement',
'WhileStatement',
'ArrowFunctionExpression',
'ClassDeclaration',
'ClassExpression',
'ForOfStatement',
'ComprehensionExpression' ],
isScopable: [function (node, opts) ],
assertScopable: [function (node, opts) ],
BLOCKPARENT_TYPES:
[ 'BlockStatement',
'DoWhileStatement',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'FunctionExpression',
'Program',
'SwitchStatement',
'WhileStatement',
'ArrowFunctionExpression',
'ForOfStatement' ],
isBlockParent: [function (node, opts) ],
assertBlockParent: [function (node, opts) ],
BLOCK_TYPES: [ 'BlockStatement', 'Program' ],
isBlock: [function (node, opts) ],
assertBlock: [function (node, opts) ],
STATEMENT_TYPES:
[ 'BlockStatement',
'BreakStatement',
'ContinueStatement',
'DebuggerStatement',
'DoWhileStatement',
'EmptyStatement',
'ExpressionStatement',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'IfStatement',
'LabeledStatement',
'ReturnStatement',
'SwitchStatement',
'ThrowStatement',
'TryStatement',
'VariableDeclaration',
'WhileStatement',
'WithStatement',
'ClassDeclaration',
'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ForOfStatement',
'ImportDeclaration',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'InterfaceDeclaration',
'TypeAlias' ],
isStatement: [function (node, opts) ],
assertStatement: [function (node, opts) ],
TERMINATORLESS_TYPES:
[ 'BreakStatement',
'ContinueStatement',
'ReturnStatement',
'ThrowStatement',
'YieldExpression',
'AwaitExpression' ],
isTerminatorless: [function (node, opts) ],
assertTerminatorless: [function (node, opts) ],
COMPLETIONSTATEMENT_TYPES:
[ 'BreakStatement',
'ContinueStatement',
'ReturnStatement',
'ThrowStatement' ],
isCompletionStatement: [function (node, opts) ],
assertCompletionStatement: [function (node, opts) ],
LOOP_TYPES:
[ 'DoWhileStatement',
'ForInStatement',
'ForStatement',
'WhileStatement',
'ForOfStatement' ],
isLoop: [function (node, opts) ],
assertLoop: [function (node, opts) ],
WHILE_TYPES: [ 'DoWhileStatement', 'WhileStatement' ],
isWhile: [function (node, opts) ],
assertWhile: [function (node, opts) ],
FOR_TYPES: [ 'ForInStatement', 'ForStatement', 'ForOfStatement' ],
isFor: [function (node, opts) ],
assertFor: [function (node, opts) ],
FORXSTATEMENT_TYPES: [ 'ForInStatement', 'ForOfStatement' ],
isForXStatement: [function (node, opts) ],
assertForXStatement: [function (node, opts) ],
FUNCTION_TYPES:
[ 'FunctionDeclaration',
'FunctionExpression',
'ArrowFunctionExpression' ],
isFunction: [function (node, opts) ],
assertFunction: [function (node, opts) ],
FUNCTIONPARENT_TYPES:
[ 'FunctionDeclaration',
'FunctionExpression',
'Program',
'ArrowFunctionExpression' ],
isFunctionParent: [function (node, opts) ],
assertFunctionParent: [function (node, opts) ],
PURE_TYPES:
[ 'FunctionDeclaration',
'FunctionExpression',
'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'ArrowFunctionExpression' ],
isPure: [function (node, opts) ],
assertPure: [function (node, opts) ],
DECLARATION_TYPES:
[ 'FunctionDeclaration',
'VariableDeclaration',
'ClassDeclaration',
'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ImportDeclaration',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'InterfaceDeclaration',
'TypeAlias' ],
isDeclaration: [function (node, opts) ],
assertDeclaration: [function (node, opts) ],
LVAL_TYPES:
[ 'Identifier',
'MemberExpression',
'AssignmentPattern',
'ArrayPattern',
'ObjectPattern' ],
isLVal: [function (node, opts) ],
assertLVal: [function (node, opts) ],
LITERAL_TYPES:
[ 'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'RegexLiteral',
'TemplateLiteral' ],
isLiteral: [function (node, opts) ],
assertLiteral: [function (node, opts) ],
IMMUTABLE_TYPES:
[ 'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'JSXAttribute',
'JSXClosingElement',
'JSXElement',
'JSXExpressionContainer',
'JSXOpeningElement' ],
isImmutable: [function isImmutable(node /*: Object*/) /*: boolean*/ ],
assertImmutable: [function (node, opts) ],
USERWHITESPACABLE_TYPES:
[ 'Property',
'ObjectTypeCallProperty',
'ObjectTypeIndexer',
'ObjectTypeProperty' ],
isUserWhitespacable: [function (node, opts) ],
assertUserWhitespacable: [function (node, opts) ],
UNARYLIKE_TYPES:
[ 'UnaryExpression',
'SpreadElement',
'RestProperty',
'SpreadProperty' ],
isUnaryLike: [function (node, opts) ],
assertUnaryLike: [function (node, opts) ],
PATTERN_TYPES: [ 'AssignmentPattern', 'ArrayPattern', 'ObjectPattern' ],
isPattern: [function (node, opts) ],
assertPattern: [function (node, opts) ],
CLASS_TYPES: [ 'ClassDeclaration', 'ClassExpression' ],
isClass: [function (node, opts) ],
assertClass: [function (node, opts) ],
MODULEDECLARATION_TYPES:
[ 'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ImportDeclaration' ],
isModuleDeclaration: [function (node, opts) ],
assertModuleDeclaration: [function (node, opts) ],
EXPORTDECLARATION_TYPES:
[ 'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration' ],
isExportDeclaration: [function (node, opts) ],
assertExportDeclaration: [function (node, opts) ],
MODULESPECIFIER_TYPES:
[ 'ExportSpecifier',
'ImportDefaultSpecifier',
'ImportNamespaceSpecifier',
'ImportSpecifier',
'ExportDefaultSpecifier',
'ExportNamespaceSpecifier' ],
isModuleSpecifier: [function (node, opts) ],
assertModuleSpecifier: [function (node, opts) ],
FLOW_TYPES:
[ 'AnyTypeAnnotation',
'ArrayTypeAnnotation',
'BooleanTypeAnnotation',
'BooleanLiteralTypeAnnotation',
'ClassImplements',
'ClassProperty',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'FunctionTypeAnnotation',
'FunctionTypeParam',
'GenericTypeAnnotation',
'InterfaceExtends',
'InterfaceDeclaration',
'IntersectionTypeAnnotation',
'MixedTypeAnnotation',
'NullableTypeAnnotation',
'NumberLiteralTypeAnnotation',
'NumberTypeAnnotation',
'StringLiteralTypeAnnotation',
'StringTypeAnnotation',
'TupleTypeAnnotation',
'TypeofTypeAnnotation',
'TypeAlias',
'TypeAnnotation',
'TypeCastExpression',
'TypeParameterDeclaration',
'TypeParameterInstantiation',
'ObjectTypeAnnotation',
'ObjectTypeCallProperty',
'ObjectTypeIndexer',
'ObjectTypeProperty',
'QualifiedTypeIdentifier',
'UnionTypeAnnotation',
'VoidTypeAnnotation' ],
isFlow: [function (node, opts) ],
assertFlow: [function (node, opts) ],
FLOWBASEANNOTATION_TYPES:
[ 'AnyTypeAnnotation',
'BooleanTypeAnnotation',
'MixedTypeAnnotation',
'NumberTypeAnnotation',
'StringTypeAnnotation',
'VoidTypeAnnotation' ],
isFlowBaseAnnotation: [function (node, opts) ],
assertFlowBaseAnnotation: [function (node, opts) ],
FLOWDECLARATION_TYPES:
[ 'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'InterfaceDeclaration',
'TypeAlias' ],
isFlowDeclaration: [function (node, opts) ],
assertFlowDeclaration: [function (node, opts) ],
JSX_TYPES:
[ 'JSXAttribute',
'JSXClosingElement',
'JSXElement',
'JSXEmptyExpression',
'JSXExpressionContainer',
'JSXIdentifier',
'JSXMemberExpression',
'JSXNamespacedName',
'JSXOpeningElement',
'JSXSpreadAttribute',
'JSXText' ],
isJSX: [function (node, opts) ],
assertJSX: [function (node, opts) ],
TYPES:
[ 'ArrayExpression',
'AssignmentExpression',
'BinaryExpression',
'Directive',
'BlockStatement',
'BreakStatement',
'CallExpression',
'CatchClause',
'ConditionalExpression',
'ContinueStatement',
'DebuggerStatement',
'DoWhileStatement',
'EmptyStatement',
'ExpressionStatement',
'File',
'ForInStatement',
'ForStatement',
'FunctionDeclaration',
'FunctionExpression',
'Identifier',
'IfStatement',
'LabeledStatement',
'StringLiteral',
'NumberLiteral',
'NullLiteral',
'BooleanLiteral',
'RegexLiteral',
'LogicalExpression',
'MemberExpression',
'NewExpression',
'ObjectExpression',
'Program',
'Property',
'RestElement',
'ReturnStatement',
'SequenceExpression',
'SwitchCase',
'SwitchStatement',
'ThisExpression',
'ThrowStatement',
'TryStatement',
'UnaryExpression',
'UpdateExpression',
'VariableDeclaration',
'VariableDeclarator',
'WhileStatement',
'WithStatement',
'AssignmentPattern',
'ArrayPattern',
'ArrowFunctionExpression',
'ClassBody',
'ClassDeclaration',
'ClassExpression',
'ExportAllDeclaration',
'ExportDefaultDeclaration',
'ExportNamedDeclaration',
'ExportSpecifier',
'ForOfStatement',
'ImportDeclaration',
'ImportDefaultSpecifier',
'ImportNamespaceSpecifier',
'ImportSpecifier',
'MetaProperty',
'MethodDefinition',
'ObjectPattern',
'SpreadElement',
'Super',
'TaggedTemplateExpression',
'TemplateElement',
'TemplateLiteral',
'YieldExpression',
'AnyTypeAnnotation',
'ArrayTypeAnnotation',
'BooleanTypeAnnotation',
'BooleanLiteralTypeAnnotation',
'ClassImplements',
'ClassProperty',
'DeclareClass',
'DeclareFunction',
'DeclareModule',
'DeclareVariable',
'FunctionTypeAnnotation',
'FunctionTypeParam',
'GenericTypeAnnotation',
'InterfaceExtends',
'InterfaceDeclaration',
'IntersectionTypeAnnotation',
'MixedTypeAnnotation',
'NullableTypeAnnotation',
'NumberLiteralTypeAnnotation',
'NumberTypeAnnotation',
'StringLiteralTypeAnnotation',
'StringTypeAnnotation',
'TupleTypeAnnotation',
'TypeofTypeAnnotation',
'TypeAlias',
'TypeAnnotation',
'TypeCastExpression',
'TypeParameterDeclaration',
'TypeParameterInstantiation',
'ObjectTypeAnnotation',
'ObjectTypeCallProperty',
'ObjectTypeIndexer',
'ObjectTypeProperty',
'QualifiedTypeIdentifier',
'UnionTypeAnnotation',
'VoidTypeAnnotation',
'JSXAttribute',
'JSXClosingElement',
'JSXElement',
'JSXEmptyExpression',
'JSXExpressionContainer',
'JSXIdentifier',
'JSXMemberExpression',
'JSXNamespacedName',
'JSXOpeningElement',
'JSXSpreadAttribute',
'JSXText',
'Noop',
'ParenthesizedExpression',
'AwaitExpression',
'BindExpression',
'ComprehensionBlock',
'ComprehensionExpression',
'Decorator',
'DoExpression',
'ExportDefaultSpecifier',
'ExportNamespaceSpecifier',
'RestProperty',
'SpreadProperty',
'Expression',
'Binary',
'Scopable',
'BlockParent',
'Block',
'Statement',
'Terminatorless',
'CompletionStatement',
'Loop',
'While',
'For',
'ForXStatement',
'Function',
'FunctionParent',
'Pure',
'Declaration',
'LVal',
'Literal',
'Immutable',
'UserWhitespacable',
'UnaryLike',
'Pattern',
'Class',
'ModuleDeclaration',
'ExportDeclaration',
'ModuleSpecifier',
'Flow',
'FlowBaseAnnotation',
'FlowDeclaration',
'JSX',
'ReferencedIdentifier',
'BindingIdentifier',
'Scope',
'Referenced',
'BlockScoped',
'Var',
'DirectiveLiteral',
'User',
'Generated' ],
ArrayExpression: [function builder() ],
arrayExpression: [function builder() ],
AssignmentExpression: [function builder() ],
assignmentExpression: [function builder() ],
BinaryExpression: [function builder() ],
binaryExpression: [function builder() ],
Directive: [function builder() ],
BlockStatement: [function builder() ],
blockStatement: [function builder() ],
BreakStatement: [function builder() ],
breakStatement: [function builder() ],
CallExpression: [function builder() ],
callExpression: [function builder() ],
CatchClause: [function builder() ],
catchClause: [function builder() ],
ConditionalExpression: [function builder() ],
conditionalExpression: [function builder() ],
ContinueStatement: [function builder() ],
continueStatement: [function builder() ],
DebuggerStatement: [function builder() ],
debuggerStatement: [function builder() ],
DoWhileStatement: [function builder() ],
doWhileStatement: [function builder() ],
EmptyStatement: [function builder() ],
emptyStatement: [function builder() ],
ExpressionStatement: [function builder() ],
expressionStatement: [function builder() ],
File: [function builder() ],
file: [function builder() ],
ForInStatement: [function builder() ],
forInStatement: [function builder() ],
ForStatement: [function builder() ],
forStatement: [function builder() ],
FunctionDeclaration: [function builder() ],
functionDeclaration: [function builder() ],
FunctionExpression: [function builder() ],
functionExpression: [function builder() ],
Identifier: [function builder() ],
identifier: [function builder() ],
IfStatement: [function builder() ],
ifStatement: [function builder() ],
LabeledStatement: [function builder() ],
labeledStatement: [function builder() ],
StringLiteral: [function builder() ],
stringLiteral: [function builder() ],
NumberLiteral: [function builder() ],
numberLiteral: [function builder() ],
NullLiteral: [function builder() ],
nullLiteral: [function builder() ],
BooleanLiteral: [function builder() ],
booleanLiteral: [function builder() ],
RegexLiteral: [function builder() ],
regexLiteral: [function builder() ],
LogicalExpression: [function builder() ],
logicalExpression: [function builder() ],
MemberExpression: [function builder() ],
memberExpression: [function builder() ],
NewExpression: [function builder() ],
newExpression: [function builder() ],
ObjectExpression: [function builder() ],
objectExpression: [function builder() ],
Program: [function builder() ],
program: [function builder() ],
Property: [function builder() ],
property: [function builder() ],
RestElement: [function builder() ],
restElement: [function builder() ],
ReturnStatement: [function builder() ],
returnStatement: [function builder() ],
SequenceExpression: [function builder() ],
sequenceExpression: [function builder() ],
SwitchCase: [function builder() ],
switchCase: [function builder() ],
SwitchStatement: [function builder() ],
switchStatement: [function builder() ],
ThisExpression: [function builder() ],
thisExpression: [function builder() ],
ThrowStatement: [function builder() ],
throwStatement: [function builder() ],
TryStatement: [function builder() ],
tryStatement: [function builder() ],
UnaryExpression: [function builder() ],
unaryExpression: [function builder() ],
UpdateExpression: [function builder() ],
updateExpression: [function builder() ],
VariableDeclaration: [function builder() ],
variableDeclaration: [function builder() ],
VariableDeclarator: [function builder() ],
variableDeclarator: [function builder() ],
WhileStatement: [function builder() ],
whileStatement: [function builder() ],
WithStatement: [function builder() ],
withStatement: [function builder() ],
AssignmentPattern: [function builder() ],
assignmentPattern: [function builder() ],
ArrayPattern: [function builder() ],
arrayPattern: [function builder() ],
ArrowFunctionExpression: [function builder() ],
arrowFunctionExpression: [function builder() ],
ClassBody: [function builder() ],
classBody: [function builder() ],
ClassDeclaration: [function builder() ],
classDeclaration: [function builder() ],
ClassExpression: [function builder() ],
classExpression: [function builder() ],
ExportAllDeclaration: [function builder() ],
exportAllDeclaration: [function builder() ],
ExportDefaultDeclaration: [function builder() ],
exportDefaultDeclaration: [function builder() ],
ExportNamedDeclaration: [function builder() ],
exportNamedDeclaration: [function builder() ],
ExportSpecifier: [function builder() ],
exportSpecifier: [function builder() ],
ForOfStatement: [function builder() ],
forOfStatement: [function builder() ],
ImportDeclaration: [function builder() ],
importDeclaration: [function builder() ],
ImportDefaultSpecifier: [function builder() ],
importDefaultSpecifier: [function builder() ],
ImportNamespaceSpecifier: [function builder() ],
importNamespaceSpecifier: [function builder() ],
ImportSpecifier: [function builder() ],
importSpecifier: [function builder() ],
MetaProperty: [function builder() ],
metaProperty: [function builder() ],
MethodDefinition: [function builder() ],
methodDefinition: [function builder() ],
ObjectPattern: [function builder() ],
objectPattern: [function builder() ],
SpreadElement: [function builder() ],
spreadElement: [function builder() ],
Super: [function builder() ],
super: [function builder() ],
TaggedTemplateExpression: [function builder() ],
taggedTemplateExpression: [function builder() ],
TemplateElement: [function builder() ],
templateElement: [function builder() ],
TemplateLiteral: [function builder() ],
templateLiteral: [function builder() ],
YieldExpression: [function builder() ],
yieldExpression: [function builder() ],
AnyTypeAnnotation: [function builder() ],
anyTypeAnnotation: [function builder() ],
ArrayTypeAnnotation: [function builder() ],
arrayTypeAnnotation: [function builder() ],
BooleanTypeAnnotation: [function builder() ],
booleanTypeAnnotation: [function builder() ],
BooleanLiteralTypeAnnotation: [function builder() ],
booleanLiteralTypeAnnotation: [function builder() ],
ClassImplements: [function builder() ],
classImplements: [function builder() ],
ClassProperty: [function builder() ],
classProperty: [function builder() ],
DeclareClass: [function builder() ],
declareClass: [function builder() ],
DeclareFunction: [function builder() ],
declareFunction: [function builder() ],
DeclareModule: [function builder() ],
declareModule: [function builder() ],
DeclareVariable: [function builder() ],
declareVariable: [function builder() ],
FunctionTypeAnnotation: [function builder() ],
functionTypeAnnotation: [function builder() ],
FunctionTypeParam: [function builder() ],
functionTypeParam: [function builder() ],
GenericTypeAnnotation: [function builder() ],
genericTypeAnnotation: [function builder() ],
InterfaceExtends: [function builder() ],
interfaceExtends: [function builder() ],
InterfaceDeclaration: [function builder() ],
interfaceDeclaration: [function builder() ],
IntersectionTypeAnnotation: [function builder() ],
intersectionTypeAnnotation: [function builder() ],
MixedTypeAnnotation: [function builder() ],
mixedTypeAnnotation: [function builder() ],
NullableTypeAnnotation: [function builder() ],
nullableTypeAnnotation: [function builder() ],
NumberLiteralTypeAnnotation: [function builder() ],
numberLiteralTypeAnnotation: [function builder() ],
NumberTypeAnnotation: [function builder() ],
numberTypeAnnotation: [function builder() ],
StringLiteralTypeAnnotation: [function builder() ],
stringLiteralTypeAnnotation: [function builder() ],
StringTypeAnnotation: [function builder() ],
stringTypeAnnotation: [function builder() ],
TupleTypeAnnotation: [function builder() ],
tupleTypeAnnotation: [function builder() ],
TypeofTypeAnnotation: [function builder() ],
typeofTypeAnnotation: [function builder() ],
TypeAlias: [function builder() ],
typeAlias: [function builder() ],
TypeAnnotation: [function builder() ],
typeAnnotation: [function builder() ],
TypeCastExpression: [function builder() ],
typeCastExpression: [function builder() ],
TypeParameterDeclaration: [function builder() ],
typeParameterDeclaration: [function builder() ],
TypeParameterInstantiation: [function builder() ],
typeParameterInstantiation: [function builder() ],
ObjectTypeAnnotation: [function builder() ],
objectTypeAnnotation: [function builder() ],
ObjectTypeCallProperty: [function builder() ],
objectTypeCallProperty: [function builder() ],
ObjectTypeIndexer: [function builder() ],
objectTypeIndexer: [function builder() ],
ObjectTypeProperty: [function builder() ],
objectTypeProperty: [function builder() ],
QualifiedTypeIdentifier: [function builder() ],
qualifiedTypeIdentifier: [function builder() ],
UnionTypeAnnotation: [function builder() ],
unionTypeAnnotation: [function builder() ],
VoidTypeAnnotation: [function builder() ],
voidTypeAnnotation: [function builder() ],
JSXAttribute: [function builder() ],
jSXAttribute: [function builder() ],
JSXClosingElement: [function builder() ],
jSXClosingElement: [function builder() ],
JSXElement: [function builder() ],
jSXElement: [function builder() ],
JSXEmptyExpression: [function builder() ],
jSXEmptyExpression: [function builder() ],
JSXExpressionContainer: [function builder() ],
jSXExpressionContainer: [function builder() ],
JSXIdentifier: [function builder() ],
jSXIdentifier: [function builder() ],
JSXMemberExpression: [function builder() ],
jSXMemberExpression: [function builder() ],
JSXNamespacedName: [function builder() ],
jSXNamespacedName: [function builder() ],
JSXOpeningElement: [function builder() ],
jSXOpeningElement: [function builder() ],
JSXSpreadAttribute: [function builder() ],
jSXSpreadAttribute: [function builder() ],
JSXText: [function builder() ],
jSXText: [function builder() ],
Noop: [function builder() ],
noop: [function builder() ],
ParenthesizedExpression: [function builder() ],
parenthesizedExpression: [function builder() ],
AwaitExpression: [function builder() ],
awaitExpression: [function builder() ],
BindExpression: [function builder() ],
bindExpression: [function builder() ],
ComprehensionBlock: [function builder() ],
comprehensionBlock: [function builder() ],
ComprehensionExpression: [function builder() ],
comprehensionExpression: [function builder() ],
Decorator: [function builder() ],
decorator: [function builder() ],
DoExpression: [function builder() ],
doExpression: [function builder() ],
ExportDefaultSpecifier: [function builder() ],
exportDefaultSpecifier: [function builder() ],
ExportNamespaceSpecifier: [function builder() ],
exportNamespaceSpecifier: [function builder() ],
RestProperty: [function builder() ],
restProperty: [function builder() ],
SpreadProperty: [function builder() ],
spreadProperty: [function builder() ],
getBindingIdentifiers: [function getBindingIdentifiers(node /*: Object*/, duplicates /*:: ?*/) /*: Object*/ ],
isBinding: [function isBinding(node /*: Object*/, parent /*: Object*/) /*: boolean*/ ],
isReferenced: [function isReferenced(node /*: Object*/, parent /*: Object*/) /*: boolean*/ ],
isValidIdentifier: [function isValidIdentifier(name /*: string*/) /*: boolean*/ ],
isLet: [function isLet(node /*: Object*/) /*: boolean*/ ],
isBlockScoped: [function isBlockScoped(node /*: Object*/) /*: boolean*/ ],
isVar: [function isVar(node /*: Object*/) /*: boolean*/ ],
isSpecifierDefault: [function isSpecifierDefault(specifier /*: Object*/) /*: boolean*/ ],
isScope: [function isScope(node /*: Object*/, parent /*: Object*/) /*: boolean*/ ],
toComputedKey: [function toComputedKey(node /*: Object*/) /*: Object*/ ],
toSequenceExpression: [function toSequenceExpression(nodes /*: Array<Object>*/, scope /*: Scope*/) /*: Object*/ ],
toKeyAlias: [function toKeyAlias(node /*: Object*/) ],
toIdentifier: [function toIdentifier(name /*: string*/) /*: string*/ ],
toBindingIdentifierName: [function toBindingIdentifierName(name) ],
toStatement: [function toStatement(node /*: Object*/, ignore /*:: ?: boolean*/) ],
toExpression: [function toExpression(node /*: Object*/) /*: Object*/ ],
toBlock: [function toBlock(node /*: Object*/, parent /*: Object*/) /*: Object*/ ],
valueToNode: [function valueToNode(value /*: any*/) /*: Object*/ ],
createUnionTypeAnnotation: [function createUnionTypeAnnotation(types) ],
removeTypeDuplicates: [function removeTypeDuplicates(nodes) ],
createTypeAnnotationBasedOnTypeof: [function createTypeAnnotationBasedOnTypeof(type) ] }
Raw
babylon-described.js
{ __esModule: true,
parse: [function parse(input, options) ],
tokTypes:
{ num:
TokenType {
label: 'num',
keyword: undefined,
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
regexp:
TokenType {
label: 'regexp',
keyword: undefined,
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
string:
TokenType {
label: 'string',
keyword: undefined,
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
name:
TokenType {
label: 'name',
keyword: undefined,
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
eof:
TokenType {
label: 'eof',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
bracketL:
TokenType {
label: '[',
keyword: undefined,
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
bracketR:
TokenType {
label: ']',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
braceL:
TokenType {
label: '{',
keyword: undefined,
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function (prevType) ] },
braceR:
TokenType {
label: '}',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function () ] },
parenL:
TokenType {
label: '(',
keyword: undefined,
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function (prevType) ] },
parenR:
TokenType {
label: ')',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function () ] },
comma:
TokenType {
label: ',',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
semi:
TokenType {
label: ';',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
colon:
TokenType {
label: ':',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
doubleColon:
TokenType {
label: '::',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
dot:
TokenType {
label: '.',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
question:
TokenType {
label: '?',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
arrow:
TokenType {
label: '=>',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
template:
TokenType {
label: 'template',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
ellipsis:
TokenType {
label: '...',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
backQuote:
TokenType {
label: '`',
keyword: undefined,
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function () ] },
dollarBraceL:
TokenType {
label: '${',
keyword: undefined,
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function () ] },
at:
TokenType {
label: '@',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
eq:
TokenType {
label: '=',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: true,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
assign:
TokenType {
label: '_=',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: true,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
incDec:
TokenType {
label: '++/--',
keyword: undefined,
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: true,
postfix: true,
binop: null,
updateContext: [function () ] },
prefix:
TokenType {
label: 'prefix',
keyword: undefined,
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: true,
postfix: false,
binop: null,
updateContext: null },
logicalOR:
TokenType {
label: '||',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 1,
updateContext: null },
logicalAND:
TokenType {
label: '&&',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 2,
updateContext: null },
bitwiseOR:
TokenType {
label: '|',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 3,
updateContext: null },
bitwiseXOR:
TokenType {
label: '^',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 4,
updateContext: null },
bitwiseAND:
TokenType {
label: '&',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 5,
updateContext: null },
equality:
TokenType {
label: '==/!=',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 6,
updateContext: null },
relational:
TokenType {
label: '</>',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 7,
updateContext: null },
bitShift:
TokenType {
label: '<</>>',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 8,
updateContext: null },
plusMin:
TokenType {
label: '+/-',
keyword: undefined,
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: true,
postfix: false,
binop: 9,
updateContext: null },
modulo:
TokenType {
label: '%',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 10,
updateContext: null },
star:
TokenType {
label: '*',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 10,
updateContext: null },
slash:
TokenType {
label: '/',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 10,
updateContext: null },
exponent:
TokenType {
label: '**',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: true,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 11,
updateContext: null },
_break:
TokenType {
label: 'break',
keyword: 'break',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_case:
TokenType {
label: 'case',
keyword: 'case',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_catch:
TokenType {
label: 'catch',
keyword: 'catch',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_continue:
TokenType {
label: 'continue',
keyword: 'continue',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_debugger:
TokenType {
label: 'debugger',
keyword: 'debugger',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_default:
TokenType {
label: 'default',
keyword: 'default',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_do:
TokenType {
label: 'do',
keyword: 'do',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: true,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_else:
TokenType {
label: 'else',
keyword: 'else',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_finally:
TokenType {
label: 'finally',
keyword: 'finally',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_for:
TokenType {
label: 'for',
keyword: 'for',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: true,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_function:
TokenType {
label: 'function',
keyword: 'function',
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function () ] },
_if:
TokenType {
label: 'if',
keyword: 'if',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_return:
TokenType {
label: 'return',
keyword: 'return',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_switch:
TokenType {
label: 'switch',
keyword: 'switch',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_throw:
TokenType {
label: 'throw',
keyword: 'throw',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_try:
TokenType {
label: 'try',
keyword: 'try',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_var:
TokenType {
label: 'var',
keyword: 'var',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_let:
TokenType {
label: 'let',
keyword: 'let',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_const:
TokenType {
label: 'const',
keyword: 'const',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_while:
TokenType {
label: 'while',
keyword: 'while',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: true,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_with:
TokenType {
label: 'with',
keyword: 'with',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_new:
TokenType {
label: 'new',
keyword: 'new',
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_this:
TokenType {
label: 'this',
keyword: 'this',
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_super:
TokenType {
label: 'super',
keyword: 'super',
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_class:
TokenType {
label: 'class',
keyword: 'class',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_extends:
TokenType {
label: 'extends',
keyword: 'extends',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_export:
TokenType {
label: 'export',
keyword: 'export',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_import:
TokenType {
label: 'import',
keyword: 'import',
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_yield:
TokenType {
label: 'yield',
keyword: 'yield',
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_null:
TokenType {
label: 'null',
keyword: 'null',
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_true:
TokenType {
label: 'true',
keyword: 'true',
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_false:
TokenType {
label: 'false',
keyword: 'false',
beforeExpr: false,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
_in:
TokenType {
label: 'in',
keyword: 'in',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 7,
updateContext: null },
_instanceof:
TokenType {
label: 'instanceof',
keyword: 'instanceof',
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: 7,
updateContext: null },
_typeof:
TokenType {
label: 'typeof',
keyword: 'typeof',
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: true,
postfix: false,
binop: null,
updateContext: null },
_void:
TokenType {
label: 'void',
keyword: 'void',
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: true,
postfix: false,
binop: null,
updateContext: null },
_delete:
TokenType {
label: 'delete',
keyword: 'delete',
beforeExpr: true,
startsExpr: true,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: true,
postfix: false,
binop: null,
updateContext: null },
jsxName:
TokenType {
label: 'jsxName',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
jsxText:
TokenType {
label: 'jsxText',
keyword: undefined,
beforeExpr: true,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: null },
jsxTagStart:
TokenType {
label: 'jsxTagStart',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function () ] },
jsxTagEnd:
TokenType {
label: 'jsxTagEnd',
keyword: undefined,
beforeExpr: false,
startsExpr: false,
rightAssociative: false,
isLoop: false,
isAssign: false,
prefix: false,
postfix: false,
binop: null,
updateContext: [function (prevType) ] } } }
Raw
generate.sh
make bootstrap
cd packages/babel-core
node -e 'Function.prototype.inspect = function(depth, opts) { return "[" + this.toString().split("{", 1)[0] + "]"; }; console.log(require("util").inspect(require("babel-types"), {depth: 5}))'
node -e 'Function.prototype.inspect = function(depth, opts) { return "[" + this.toString().split("{", 1)[0] + "]"; }; console.log(require("util").inspect(require("babylon"), {depth: 5}))'
# TODO: use this data to generate a tern manual types file - http://ternjs.net/doc/manual.html#typedef
Raw
misc
// babel-traverse
[function traverse(parent /*: Object*/, opts /*:: ?: Object*/, scope /*:: ?: Object*/, state /*: Object*/, parentPath /*: Object*/) ]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment