decaffeinate-traverse/dist/decaffeinate-traverse.js.flow

Traverse programs parsed using decaffeinate-parser.

declare type ArrayInitialiser = {
  type: 'ArrayInitialiser';
  members: Array<Expression | Expansion>;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type AssignOp = {
  type: 'AssignOp';
  assignee: Assignee;
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type BitAndOp = {
  type: 'BitAndOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type BitNotOp = {
  type: 'BitNotOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type BitOrOp = {
  type: 'BitOrOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type BitXorOp = {
  type: 'BitXorOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Block = {
  type: 'Block';
  statements: Array<Statement>;
  inline: boolean;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Bool = {
  type: 'Bool';
  data: boolean;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type BoundFunction = {
  type: 'BoundFunction';
  parameters: Array<Parameter>;
  body: ?Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Break = {
  type: 'Break';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ChainedComparisonOp = {
  type: 'ChainedComparisonOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Class_ = {
  type: 'Class';
  nameAssignee: ?Assignee;
  parent: ?Expression;
  body: ?Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ClassProtoAssignOp = {
  type: 'ClassProtoAssignOp';
  assignee: Assignee;
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type CompoundAssignOp = {
  type: 'CompoundAssignOp';
  assignee: Assignee;
  expression: Expression;
  op: 'EQOp' | 'NEQOp' | 'LogicalAndOp' | 'LogicalOrOp' | 'PlusOp' | 'SubtractOp' | 'MultiplyOp' | 'DivideOp' | 'RemOp' | 'ModuloOp' | 'BitAndOp' | 'BitOrOp' | 'BitXorOp' | 'LTOp' | 'GTOp' | 'LTEOp' | 'GTEOp' | 'OfOp' | 'ExistsOp' | 'InstanceofOp' | 'LeftShiftOp' | 'SignedRightShiftOp' | 'UnsignedRightShiftOp' | 'ExpOp' | 'FloorDivideOp';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Conditional = {
  type: 'Conditional';
  condition: Expression;
  consequent: ?Block;
  alternate: ?Block;
  isUnless: boolean;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Constructor = {
  type: 'Constructor';
  assignee: Assignee;
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Continue = {
  type: 'Continue';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type DefaultParam = {
  type: 'DefaultParam';
  param: Parameter;
  default: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type DeleteOp = {
  type: 'DeleteOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type DivideOp = {
  type: 'DivideOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type DoOp = {
  type: 'DoOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type DynamicMemberAccessOp = {
  type: 'DynamicMemberAccessOp';
  expression: Expression;
  indexingExpr: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type EQOp = {
  type: 'EQOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ExistsOp = {
  type: 'ExistsOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ExpOp = {
  type: 'ExpOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Expansion = {
  type: 'Expansion';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ExtendsOp = {
  type: 'ExtendsOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Float = {
  type: 'Float';
  data: number;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type FloorDivideOp = {
  type: 'FloorDivideOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ForIn = {
  type: 'ForIn';
  keyAssignee: ?Assignee;
  valAssignee: ?Assignee;
  target: Expression;
  step: ?Expression;
  filter: ?Expression;
  body: Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ForOf = {
  type: 'ForOf';
  keyAssignee: Assignee;
  valAssignee: ?Assignee;
  target: Expression;
  filter: ?Expression;
  body: Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Function_ = {
  type: 'Function';
  parameters: Array<Parameter>;
  body: ?Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type FunctionApplication = {
  type: 'FunctionApplication';
  function: Expression;
  arguments: Array<Expression | Expansion>;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type GeneratorFunction = {
  type: 'GeneratorFunction';
  parameters: Array<Parameter>;
  body: Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type GTEOp = {
  type: 'GTEOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type GTOp = {
  type: 'GTOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Herestring = {
  type: 'Herestring';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Identifier = {
  type: 'Identifier';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type InOp = {
  type: 'InOp';
  left: Expression;
  right: Expression;
  isNot: boolean;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type InstanceofOp = {
  type: 'InstanceofOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Int = {
  type: 'Int';
  data: number;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type JavaScript = {
  type: 'JavaScript';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type LTEOp = {
  type: 'LTEOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type LTOp = {
  type: 'LTOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type LeftShiftOp = {
  type: 'LeftShiftOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type LogicalAndOp = {
  type: 'LogicalAndOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type LogicalNotOp = {
  type: 'LogicalNotOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type LogicalOrOp = {
  type: 'LogicalOrOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type MemberAccessOp = {
  type: 'MemberAccessOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type MultiplyOp = {
  type: 'MultiplyOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type NEQOp = {
  type: 'NEQOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type NewOp = {
  type: 'NewOp';
  ctor: Expression;
  arguments: Array<Expression>;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Null = {
  type: 'Null';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ObjectInitialiser = {
  type: 'ObjectInitialiser';
  members: Array<ObjectInitialiserMember>;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ObjectInitialiserMember = {
  type: 'ObjectInitialiserMember';
  key: Identifier | String;
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type OfOp = {
  type: 'OfOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type PlusOp = {
  type: 'PlusOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type PostDecrementOp = {
  type: 'PostDecrementOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type PostIncrementOp = {
  type: 'PostIncrementOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type PreDecrementOp = {
  type: 'PreDecrementOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type PreIncrementOp = {
  type: 'PreIncrementOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Program = {
  type: 'Program';
  body: ?Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type ProtoMemberAccessOp = {
  type: 'ProtoMemberAccessOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Range = {
  type: 'Range';
  left: Expression;
  right: Expression;
  isInclusive: boolean;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type RegExp = {
  type: 'RegExp';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type RemOp = {
  type: 'RemOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Rest = {
  type: 'Rest';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Return = {
  type: 'Return';
  expression: ?Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SeqOp = {
  type: 'SeqOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SignedRightShiftOp = {
  type: 'SignedRightShiftOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Slice = {
  type: 'Slice';
  expression: Expression;
  left: ?Expression;
  right: ?Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SoakedDynamicMemberAccessOp = {
  type: 'SoakedDynamicMemberAccessOp';
  expression: Expression;
  indexingExpr: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SoakedFunctionApplication = {
  type: 'SoakedFunctionApplication';
  function: Expression;
  arguments: Array<Expression | Expansion>;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SoakedMemberAccessOp = {
  type: 'SoakedMemberAccessOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Spread = {
  type: 'Spread';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type String = {
  type: 'String';
  data: string;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SubtractOp = {
  type: 'SubtractOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Super = {
  type: 'Super';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Switch = {
  type: 'Switch';
  expression: ?Expression;
  cases: Array<SwitchCase>;
  alternate: ?Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type SwitchCase = {
  type: 'SwitchCase';
  conditions: Array<Expression>;
  consequent: Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type TemplateLiteral = {
  type: 'TemplateLiteral';
  quasis: Array<String>;
  expressions: Array<Expression>;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type This = {
  type: 'This';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Throw = {
  type: 'Throw';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Try = {
  type: 'Try';
  body: Block;
  catchAssignee: ?Assignee;
  catchBody: ?Block;
  finallyBody: ?Block;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type TypeofOp = {
  type: 'TypeofOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type UnaryExistsOp = {
  type: 'UnaryExistsOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type UnaryNegateOp = {
  type: 'UnaryNegateOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type UnaryPlusOp = {
  type: 'UnaryPlusOp';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Undefined = {
  type: 'Undefined';
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type UnsignedRightShiftOp = {
  type: 'UnsignedRightShiftOp';
  left: Expression;
  right: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type While = {
  type: 'While';
  condition: Expression;
  guard: ?Expression;
  body: Block;
  isUntil: boolean;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Yield = {
  type: 'Yield';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type YieldFrom = {
  type: 'YieldFrom';
  expression: Expression;
  raw: string;
  line: number;
  column: number;
  range: [ number, number ];
  virtual?: boolean;
};

declare type Expression =
  ArrayInitialiser |
  AssignOp |
  BitAndOp |
  BitNotOp |
  BitOrOp |
  BitXorOp |
  Bool |
  BoundFunction |
  ChainedComparisonOp |
  Class_ |
  ClassProtoAssignOp |
  CompoundAssignOp |
  Conditional |
  DivideOp |
  DoOp |
  DynamicMemberAccessOp |
  EQOp |
  ExistsOp |
  ExpOp |
  ExtendsOp |
  Float |
  FloorDivideOp |
  ForIn |
  ForOf |
  Function_ |
  FunctionApplication |
  GeneratorFunction |
  GTEOp |
  GTOp |
  Herestring |
  Identifier |
  InOp |
  InstanceofOp |
  Int |
  JavaScript |
  LTEOp |
  LTOp |
  LeftShiftOp |
  LogicalAndOp |
  LogicalNotOp |
  LogicalOrOp |
  MemberAccessOp |
  MultiplyOp |
  NEQOp |
  NewOp |
  Null |
  ObjectInitialiser |
  ObjectInitialiserMember |
  OfOp |
  PlusOp |
  PostDecrementOp |
  PostIncrementOp |
  PreDecrementOp |
  PreIncrementOp |
  ProtoMemberAccessOp |
  Range |
  RegExp |
  RemOp |
  Rest |
  Return |
  SeqOp |
  SignedRightShiftOp |
  Slice |
  SoakedDynamicMemberAccessOp |
  SoakedFunctionApplication |
  SoakedMemberAccessOp |
  Spread |
  String |
  SubtractOp |
  Super |
  Switch |
  TemplateLiteral |
  This |
  Throw |
  Try |
  TypeofOp |
  UnaryExistsOp |
  UnaryNegateOp |
  UnaryPlusOp |
  Undefined |
  UnsignedRightShiftOp |
  While |
  Yield |
  YieldFrom;

declare type Node =
  Block |
  DefaultParam |
  Expansion |
  Program |
  Statement |
  SwitchCase;

declare type Functions =
  BoundFunction |
  Function_ |
  GeneratorFunction;

declare type Statement =
  Break |
  Constructor |
  Continue |
  DeleteOp |
  Expression;

declare type Assignee =
  DynamicMemberAccessOp |
  Identifier |
  MemberAccessOp |
  ProtoMemberAccessOp |
  SoakedDynamicMemberAccessOp |
  SoakedMemberAccessOp;

declare type Parameter =
  DynamicMemberAccessOp |
  Identifier |
  MemberAccessOp |
  ProtoMemberAccessOp |
  SoakedDynamicMemberAccessOp |
  SoakedMemberAccessOp;