traceur/dist/commonjs/syntax/trees/ParseTrees.js

ES6 to ES5 compiler

"use strict";
function $__interopRequire(id) {
  id = require(id);
  return id && id.__esModule && id || {default: id};
}
Object.defineProperties(module.exports, {
  __esModule: {value: true},
  Annotation: {
    enumerable: true,
    get: function() {
      return Annotation;
    }
  },
  AnonBlock: {
    enumerable: true,
    get: function() {
      return AnonBlock;
    }
  },
  ArgumentList: {
    enumerable: true,
    get: function() {
      return ArgumentList;
    }
  },
  ArrayComprehension: {
    enumerable: true,
    get: function() {
      return ArrayComprehension;
    }
  },
  ArrayLiteral: {
    enumerable: true,
    get: function() {
      return ArrayLiteral;
    }
  },
  ArrayPattern: {
    enumerable: true,
    get: function() {
      return ArrayPattern;
    }
  },
  ArrayType: {
    enumerable: true,
    get: function() {
      return ArrayType;
    }
  },
  ArrowFunction: {
    enumerable: true,
    get: function() {
      return ArrowFunction;
    }
  },
  AssignmentElement: {
    enumerable: true,
    get: function() {
      return AssignmentElement;
    }
  },
  AwaitExpression: {
    enumerable: true,
    get: function() {
      return AwaitExpression;
    }
  },
  BinaryExpression: {
    enumerable: true,
    get: function() {
      return BinaryExpression;
    }
  },
  BindingElement: {
    enumerable: true,
    get: function() {
      return BindingElement;
    }
  },
  BindingIdentifier: {
    enumerable: true,
    get: function() {
      return BindingIdentifier;
    }
  },
  Block: {
    enumerable: true,
    get: function() {
      return Block;
    }
  },
  BreakStatement: {
    enumerable: true,
    get: function() {
      return BreakStatement;
    }
  },
  CallExpression: {
    enumerable: true,
    get: function() {
      return CallExpression;
    }
  },
  CallSignature: {
    enumerable: true,
    get: function() {
      return CallSignature;
    }
  },
  CaseClause: {
    enumerable: true,
    get: function() {
      return CaseClause;
    }
  },
  Catch: {
    enumerable: true,
    get: function() {
      return Catch;
    }
  },
  ClassDeclaration: {
    enumerable: true,
    get: function() {
      return ClassDeclaration;
    }
  },
  ClassExpression: {
    enumerable: true,
    get: function() {
      return ClassExpression;
    }
  },
  CommaExpression: {
    enumerable: true,
    get: function() {
      return CommaExpression;
    }
  },
  ComprehensionFor: {
    enumerable: true,
    get: function() {
      return ComprehensionFor;
    }
  },
  ComprehensionIf: {
    enumerable: true,
    get: function() {
      return ComprehensionIf;
    }
  },
  ComputedPropertyName: {
    enumerable: true,
    get: function() {
      return ComputedPropertyName;
    }
  },
  ConditionalExpression: {
    enumerable: true,
    get: function() {
      return ConditionalExpression;
    }
  },
  ConstructSignature: {
    enumerable: true,
    get: function() {
      return ConstructSignature;
    }
  },
  ConstructorType: {
    enumerable: true,
    get: function() {
      return ConstructorType;
    }
  },
  ContinueStatement: {
    enumerable: true,
    get: function() {
      return ContinueStatement;
    }
  },
  CoverFormals: {
    enumerable: true,
    get: function() {
      return CoverFormals;
    }
  },
  CoverInitializedName: {
    enumerable: true,
    get: function() {
      return CoverInitializedName;
    }
  },
  DebuggerStatement: {
    enumerable: true,
    get: function() {
      return DebuggerStatement;
    }
  },
  DefaultClause: {
    enumerable: true,
    get: function() {
      return DefaultClause;
    }
  },
  DoWhileStatement: {
    enumerable: true,
    get: function() {
      return DoWhileStatement;
    }
  },
  EmptyStatement: {
    enumerable: true,
    get: function() {
      return EmptyStatement;
    }
  },
  ExportDeclaration: {
    enumerable: true,
    get: function() {
      return ExportDeclaration;
    }
  },
  ExportDefault: {
    enumerable: true,
    get: function() {
      return ExportDefault;
    }
  },
  ExportSpecifier: {
    enumerable: true,
    get: function() {
      return ExportSpecifier;
    }
  },
  ExportSpecifierSet: {
    enumerable: true,
    get: function() {
      return ExportSpecifierSet;
    }
  },
  ExportStar: {
    enumerable: true,
    get: function() {
      return ExportStar;
    }
  },
  ExpressionStatement: {
    enumerable: true,
    get: function() {
      return ExpressionStatement;
    }
  },
  Finally: {
    enumerable: true,
    get: function() {
      return Finally;
    }
  },
  ForInStatement: {
    enumerable: true,
    get: function() {
      return ForInStatement;
    }
  },
  ForOfStatement: {
    enumerable: true,
    get: function() {
      return ForOfStatement;
    }
  },
  ForOnStatement: {
    enumerable: true,
    get: function() {
      return ForOnStatement;
    }
  },
  ForStatement: {
    enumerable: true,
    get: function() {
      return ForStatement;
    }
  },
  FormalParameter: {
    enumerable: true,
    get: function() {
      return FormalParameter;
    }
  },
  FormalParameterList: {
    enumerable: true,
    get: function() {
      return FormalParameterList;
    }
  },
  ForwardDefaultExport: {
    enumerable: true,
    get: function() {
      return ForwardDefaultExport;
    }
  },
  FunctionBody: {
    enumerable: true,
    get: function() {
      return FunctionBody;
    }
  },
  FunctionDeclaration: {
    enumerable: true,
    get: function() {
      return FunctionDeclaration;
    }
  },
  FunctionExpression: {
    enumerable: true,
    get: function() {
      return FunctionExpression;
    }
  },
  FunctionType: {
    enumerable: true,
    get: function() {
      return FunctionType;
    }
  },
  GeneratorComprehension: {
    enumerable: true,
    get: function() {
      return GeneratorComprehension;
    }
  },
  GetAccessor: {
    enumerable: true,
    get: function() {
      return GetAccessor;
    }
  },
  IdentifierExpression: {
    enumerable: true,
    get: function() {
      return IdentifierExpression;
    }
  },
  IfStatement: {
    enumerable: true,
    get: function() {
      return IfStatement;
    }
  },
  ImportedBinding: {
    enumerable: true,
    get: function() {
      return ImportedBinding;
    }
  },
  ImportClausePair: {
    enumerable: true,
    get: function() {
      return ImportClausePair;
    }
  },
  ImportDeclaration: {
    enumerable: true,
    get: function() {
      return ImportDeclaration;
    }
  },
  ImportSpecifier: {
    enumerable: true,
    get: function() {
      return ImportSpecifier;
    }
  },
  ImportSpecifierSet: {
    enumerable: true,
    get: function() {
      return ImportSpecifierSet;
    }
  },
  ImportTypeClause: {
    enumerable: true,
    get: function() {
      return ImportTypeClause;
    }
  },
  IndexSignature: {
    enumerable: true,
    get: function() {
      return IndexSignature;
    }
  },
  InterfaceDeclaration: {
    enumerable: true,
    get: function() {
      return InterfaceDeclaration;
    }
  },
  JsxAttribute: {
    enumerable: true,
    get: function() {
      return JsxAttribute;
    }
  },
  JsxElement: {
    enumerable: true,
    get: function() {
      return JsxElement;
    }
  },
  JsxElementName: {
    enumerable: true,
    get: function() {
      return JsxElementName;
    }
  },
  JsxPlaceholder: {
    enumerable: true,
    get: function() {
      return JsxPlaceholder;
    }
  },
  JsxSpreadAttribute: {
    enumerable: true,
    get: function() {
      return JsxSpreadAttribute;
    }
  },
  JsxText: {
    enumerable: true,
    get: function() {
      return JsxText;
    }
  },
  LabelledStatement: {
    enumerable: true,
    get: function() {
      return LabelledStatement;
    }
  },
  LiteralExpression: {
    enumerable: true,
    get: function() {
      return LiteralExpression;
    }
  },
  LiteralPropertyName: {
    enumerable: true,
    get: function() {
      return LiteralPropertyName;
    }
  },
  MemberExpression: {
    enumerable: true,
    get: function() {
      return MemberExpression;
    }
  },
  MemberLookupExpression: {
    enumerable: true,
    get: function() {
      return MemberLookupExpression;
    }
  },
  Method: {
    enumerable: true,
    get: function() {
      return Method;
    }
  },
  MethodSignature: {
    enumerable: true,
    get: function() {
      return MethodSignature;
    }
  },
  Module: {
    enumerable: true,
    get: function() {
      return Module;
    }
  },
  ModuleSpecifier: {
    enumerable: true,
    get: function() {
      return ModuleSpecifier;
    }
  },
  NameSpaceExport: {
    enumerable: true,
    get: function() {
      return NameSpaceExport;
    }
  },
  NameSpaceImport: {
    enumerable: true,
    get: function() {
      return NameSpaceImport;
    }
  },
  NamedExport: {
    enumerable: true,
    get: function() {
      return NamedExport;
    }
  },
  NewExpression: {
    enumerable: true,
    get: function() {
      return NewExpression;
    }
  },
  ObjectLiteral: {
    enumerable: true,
    get: function() {
      return ObjectLiteral;
    }
  },
  ObjectPattern: {
    enumerable: true,
    get: function() {
      return ObjectPattern;
    }
  },
  ObjectPatternField: {
    enumerable: true,
    get: function() {
      return ObjectPatternField;
    }
  },
  ObjectType: {
    enumerable: true,
    get: function() {
      return ObjectType;
    }
  },
  ParenExpression: {
    enumerable: true,
    get: function() {
      return ParenExpression;
    }
  },
  PostfixExpression: {
    enumerable: true,
    get: function() {
      return PostfixExpression;
    }
  },
  PredefinedType: {
    enumerable: true,
    get: function() {
      return PredefinedType;
    }
  },
  Script: {
    enumerable: true,
    get: function() {
      return Script;
    }
  },
  PropertyNameAssignment: {
    enumerable: true,
    get: function() {
      return PropertyNameAssignment;
    }
  },
  PropertyNameShorthand: {
    enumerable: true,
    get: function() {
      return PropertyNameShorthand;
    }
  },
  PropertyVariableDeclaration: {
    enumerable: true,
    get: function() {
      return PropertyVariableDeclaration;
    }
  },
  PropertySignature: {
    enumerable: true,
    get: function() {
      return PropertySignature;
    }
  },
  RestParameter: {
    enumerable: true,
    get: function() {
      return RestParameter;
    }
  },
  ReturnStatement: {
    enumerable: true,
    get: function() {
      return ReturnStatement;
    }
  },
  SetAccessor: {
    enumerable: true,
    get: function() {
      return SetAccessor;
    }
  },
  SpreadExpression: {
    enumerable: true,
    get: function() {
      return SpreadExpression;
    }
  },
  SpreadPatternElement: {
    enumerable: true,
    get: function() {
      return SpreadPatternElement;
    }
  },
  SuperExpression: {
    enumerable: true,
    get: function() {
      return SuperExpression;
    }
  },
  SwitchStatement: {
    enumerable: true,
    get: function() {
      return SwitchStatement;
    }
  },
  SyntaxErrorTree: {
    enumerable: true,
    get: function() {
      return SyntaxErrorTree;
    }
  },
  TemplateLiteralExpression: {
    enumerable: true,
    get: function() {
      return TemplateLiteralExpression;
    }
  },
  TemplateLiteralPortion: {
    enumerable: true,
    get: function() {
      return TemplateLiteralPortion;
    }
  },
  TemplateSubstitution: {
    enumerable: true,
    get: function() {
      return TemplateSubstitution;
    }
  },
  ThisExpression: {
    enumerable: true,
    get: function() {
      return ThisExpression;
    }
  },
  ThrowStatement: {
    enumerable: true,
    get: function() {
      return ThrowStatement;
    }
  },
  TryStatement: {
    enumerable: true,
    get: function() {
      return TryStatement;
    }
  },
  TypeAliasDeclaration: {
    enumerable: true,
    get: function() {
      return TypeAliasDeclaration;
    }
  },
  TypeArguments: {
    enumerable: true,
    get: function() {
      return TypeArguments;
    }
  },
  TypeName: {
    enumerable: true,
    get: function() {
      return TypeName;
    }
  },
  TypeParameter: {
    enumerable: true,
    get: function() {
      return TypeParameter;
    }
  },
  TypeParameters: {
    enumerable: true,
    get: function() {
      return TypeParameters;
    }
  },
  TypeReference: {
    enumerable: true,
    get: function() {
      return TypeReference;
    }
  },
  UnaryExpression: {
    enumerable: true,
    get: function() {
      return UnaryExpression;
    }
  },
  UnionType: {
    enumerable: true,
    get: function() {
      return UnionType;
    }
  },
  VariableDeclaration: {
    enumerable: true,
    get: function() {
      return VariableDeclaration;
    }
  },
  VariableDeclarationList: {
    enumerable: true,
    get: function() {
      return VariableDeclarationList;
    }
  },
  VariableStatement: {
    enumerable: true,
    get: function() {
      return VariableStatement;
    }
  },
  WhileStatement: {
    enumerable: true,
    get: function() {
      return WhileStatement;
    }
  },
  WithStatement: {
    enumerable: true,
    get: function() {
      return WithStatement;
    }
  },
  YieldExpression: {
    enumerable: true,
    get: function() {
      return YieldExpression;
    }
  }
});
var $__createClass = $__interopRequire("traceur/dist/commonjs/runtime/modules/createClass.js").default;
var $__superConstructor = $__interopRequire("traceur/dist/commonjs/runtime/modules/superConstructor.js").default;
var ParseTree = require("./ParseTree.js").ParseTree;
var ParseTreeType = $__interopRequire("./ParseTreeType.js");
var ANNOTATION = ParseTreeType.ANNOTATION;
var Annotation = function($__super) {
  function Annotation(location, name, args) {
    $__superConstructor(Annotation).call(this, location);
    this.name = name;
    this.args = args;
  }
  return ($__createClass)(Annotation, {
    transform: function(transformer) {
      return transformer.transformAnnotation(this);
    },
    visit: function(visitor) {
      visitor.visitAnnotation(this);
    },
    get type() {
      return ANNOTATION;
    }
  }, {}, $__super);
}(ParseTree);
var ANON_BLOCK = ParseTreeType.ANON_BLOCK;
var AnonBlock = function($__super) {
  function AnonBlock(location, statements) {
    $__superConstructor(AnonBlock).call(this, location);
    this.statements = statements;
  }
  return ($__createClass)(AnonBlock, {
    transform: function(transformer) {
      return transformer.transformAnonBlock(this);
    },
    visit: function(visitor) {
      visitor.visitAnonBlock(this);
    },
    get type() {
      return ANON_BLOCK;
    }
  }, {}, $__super);
}(ParseTree);
var ARGUMENT_LIST = ParseTreeType.ARGUMENT_LIST;
var ArgumentList = function($__super) {
  function ArgumentList(location, args) {
    $__superConstructor(ArgumentList).call(this, location);
    this.args = args;
  }
  return ($__createClass)(ArgumentList, {
    transform: function(transformer) {
      return transformer.transformArgumentList(this);
    },
    visit: function(visitor) {
      visitor.visitArgumentList(this);
    },
    get type() {
      return ARGUMENT_LIST;
    }
  }, {}, $__super);
}(ParseTree);
var ARRAY_COMPREHENSION = ParseTreeType.ARRAY_COMPREHENSION;
var ArrayComprehension = function($__super) {
  function ArrayComprehension(location, comprehensionList, expression) {
    $__superConstructor(ArrayComprehension).call(this, location);
    this.comprehensionList = comprehensionList;
    this.expression = expression;
  }
  return ($__createClass)(ArrayComprehension, {
    transform: function(transformer) {
      return transformer.transformArrayComprehension(this);
    },
    visit: function(visitor) {
      visitor.visitArrayComprehension(this);
    },
    get type() {
      return ARRAY_COMPREHENSION;
    }
  }, {}, $__super);
}(ParseTree);
var ARRAY_LITERAL = ParseTreeType.ARRAY_LITERAL;
var ArrayLiteral = function($__super) {
  function ArrayLiteral(location, elements) {
    $__superConstructor(ArrayLiteral).call(this, location);
    this.elements = elements;
  }
  return ($__createClass)(ArrayLiteral, {
    transform: function(transformer) {
      return transformer.transformArrayLiteral(this);
    },
    visit: function(visitor) {
      visitor.visitArrayLiteral(this);
    },
    get type() {
      return ARRAY_LITERAL;
    }
  }, {}, $__super);
}(ParseTree);
var ARRAY_PATTERN = ParseTreeType.ARRAY_PATTERN;
var ArrayPattern = function($__super) {
  function ArrayPattern(location, elements) {
    $__superConstructor(ArrayPattern).call(this, location);
    this.elements = elements;
  }
  return ($__createClass)(ArrayPattern, {
    transform: function(transformer) {
      return transformer.transformArrayPattern(this);
    },
    visit: function(visitor) {
      visitor.visitArrayPattern(this);
    },
    get type() {
      return ARRAY_PATTERN;
    }
  }, {}, $__super);
}(ParseTree);
var ARRAY_TYPE = ParseTreeType.ARRAY_TYPE;
var ArrayType = function($__super) {
  function ArrayType(location, elementType) {
    $__superConstructor(ArrayType).call(this, location);
    this.elementType = elementType;
  }
  return ($__createClass)(ArrayType, {
    transform: function(transformer) {
      return transformer.transformArrayType(this);
    },
    visit: function(visitor) {
      visitor.visitArrayType(this);
    },
    get type() {
      return ARRAY_TYPE;
    }
  }, {}, $__super);
}(ParseTree);
var ARROW_FUNCTION = ParseTreeType.ARROW_FUNCTION;
var ArrowFunction = function($__super) {
  function ArrowFunction(location, functionKind, parameterList, body) {
    $__superConstructor(ArrowFunction).call(this, location);
    this.functionKind = functionKind;
    this.parameterList = parameterList;
    this.body = body;
  }
  return ($__createClass)(ArrowFunction, {
    transform: function(transformer) {
      return transformer.transformArrowFunction(this);
    },
    visit: function(visitor) {
      visitor.visitArrowFunction(this);
    },
    get type() {
      return ARROW_FUNCTION;
    }
  }, {}, $__super);
}(ParseTree);
var ASSIGNMENT_ELEMENT = ParseTreeType.ASSIGNMENT_ELEMENT;
var AssignmentElement = function($__super) {
  function AssignmentElement(location, assignment, initializer) {
    $__superConstructor(AssignmentElement).call(this, location);
    this.assignment = assignment;
    this.initializer = initializer;
  }
  return ($__createClass)(AssignmentElement, {
    transform: function(transformer) {
      return transformer.transformAssignmentElement(this);
    },
    visit: function(visitor) {
      visitor.visitAssignmentElement(this);
    },
    get type() {
      return ASSIGNMENT_ELEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var AWAIT_EXPRESSION = ParseTreeType.AWAIT_EXPRESSION;
var AwaitExpression = function($__super) {
  function AwaitExpression(location, expression) {
    $__superConstructor(AwaitExpression).call(this, location);
    this.expression = expression;
  }
  return ($__createClass)(AwaitExpression, {
    transform: function(transformer) {
      return transformer.transformAwaitExpression(this);
    },
    visit: function(visitor) {
      visitor.visitAwaitExpression(this);
    },
    get type() {
      return AWAIT_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var BINARY_EXPRESSION = ParseTreeType.BINARY_EXPRESSION;
var BinaryExpression = function($__super) {
  function BinaryExpression(location, left, operator, right) {
    $__superConstructor(BinaryExpression).call(this, location);
    this.left = left;
    this.operator = operator;
    this.right = right;
  }
  return ($__createClass)(BinaryExpression, {
    transform: function(transformer) {
      return transformer.transformBinaryExpression(this);
    },
    visit: function(visitor) {
      visitor.visitBinaryExpression(this);
    },
    get type() {
      return BINARY_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var BINDING_ELEMENT = ParseTreeType.BINDING_ELEMENT;
var BindingElement = function($__super) {
  function BindingElement(location, binding, initializer) {
    $__superConstructor(BindingElement).call(this, location);
    this.binding = binding;
    this.initializer = initializer;
  }
  return ($__createClass)(BindingElement, {
    transform: function(transformer) {
      return transformer.transformBindingElement(this);
    },
    visit: function(visitor) {
      visitor.visitBindingElement(this);
    },
    get type() {
      return BINDING_ELEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var BINDING_IDENTIFIER = ParseTreeType.BINDING_IDENTIFIER;
var BindingIdentifier = function($__super) {
  function BindingIdentifier(location, identifierToken) {
    $__superConstructor(BindingIdentifier).call(this, location);
    this.identifierToken = identifierToken;
  }
  return ($__createClass)(BindingIdentifier, {
    transform: function(transformer) {
      return transformer.transformBindingIdentifier(this);
    },
    visit: function(visitor) {
      visitor.visitBindingIdentifier(this);
    },
    get type() {
      return BINDING_IDENTIFIER;
    }
  }, {}, $__super);
}(ParseTree);
var BLOCK = ParseTreeType.BLOCK;
var Block = function($__super) {
  function Block(location, statements) {
    $__superConstructor(Block).call(this, location);
    this.statements = statements;
  }
  return ($__createClass)(Block, {
    transform: function(transformer) {
      return transformer.transformBlock(this);
    },
    visit: function(visitor) {
      visitor.visitBlock(this);
    },
    get type() {
      return BLOCK;
    }
  }, {}, $__super);
}(ParseTree);
var BREAK_STATEMENT = ParseTreeType.BREAK_STATEMENT;
var BreakStatement = function($__super) {
  function BreakStatement(location, name) {
    $__superConstructor(BreakStatement).call(this, location);
    this.name = name;
  }
  return ($__createClass)(BreakStatement, {
    transform: function(transformer) {
      return transformer.transformBreakStatement(this);
    },
    visit: function(visitor) {
      visitor.visitBreakStatement(this);
    },
    get type() {
      return BREAK_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var CALL_EXPRESSION = ParseTreeType.CALL_EXPRESSION;
var CallExpression = function($__super) {
  function CallExpression(location, operand, args) {
    $__superConstructor(CallExpression).call(this, location);
    this.operand = operand;
    this.args = args;
  }
  return ($__createClass)(CallExpression, {
    transform: function(transformer) {
      return transformer.transformCallExpression(this);
    },
    visit: function(visitor) {
      visitor.visitCallExpression(this);
    },
    get type() {
      return CALL_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var CALL_SIGNATURE = ParseTreeType.CALL_SIGNATURE;
var CallSignature = function($__super) {
  function CallSignature(location, typeParameters, parameterList, returnType) {
    $__superConstructor(CallSignature).call(this, location);
    this.typeParameters = typeParameters;
    this.parameterList = parameterList;
    this.returnType = returnType;
  }
  return ($__createClass)(CallSignature, {
    transform: function(transformer) {
      return transformer.transformCallSignature(this);
    },
    visit: function(visitor) {
      visitor.visitCallSignature(this);
    },
    get type() {
      return CALL_SIGNATURE;
    }
  }, {}, $__super);
}(ParseTree);
var CASE_CLAUSE = ParseTreeType.CASE_CLAUSE;
var CaseClause = function($__super) {
  function CaseClause(location, expression, statements) {
    $__superConstructor(CaseClause).call(this, location);
    this.expression = expression;
    this.statements = statements;
  }
  return ($__createClass)(CaseClause, {
    transform: function(transformer) {
      return transformer.transformCaseClause(this);
    },
    visit: function(visitor) {
      visitor.visitCaseClause(this);
    },
    get type() {
      return CASE_CLAUSE;
    }
  }, {}, $__super);
}(ParseTree);
var CATCH = ParseTreeType.CATCH;
var Catch = function($__super) {
  function Catch(location, binding, catchBody) {
    $__superConstructor(Catch).call(this, location);
    this.binding = binding;
    this.catchBody = catchBody;
  }
  return ($__createClass)(Catch, {
    transform: function(transformer) {
      return transformer.transformCatch(this);
    },
    visit: function(visitor) {
      visitor.visitCatch(this);
    },
    get type() {
      return CATCH;
    }
  }, {}, $__super);
}(ParseTree);
var CLASS_DECLARATION = ParseTreeType.CLASS_DECLARATION;
var ClassDeclaration = function($__super) {
  function ClassDeclaration(location, name, superClass, elements, annotations, typeParameters) {
    $__superConstructor(ClassDeclaration).call(this, location);
    this.name = name;
    this.superClass = superClass;
    this.elements = elements;
    this.annotations = annotations;
    this.typeParameters = typeParameters;
  }
  return ($__createClass)(ClassDeclaration, {
    transform: function(transformer) {
      return transformer.transformClassDeclaration(this);
    },
    visit: function(visitor) {
      visitor.visitClassDeclaration(this);
    },
    get type() {
      return CLASS_DECLARATION;
    }
  }, {}, $__super);
}(ParseTree);
var CLASS_EXPRESSION = ParseTreeType.CLASS_EXPRESSION;
var ClassExpression = function($__super) {
  function ClassExpression(location, name, superClass, elements, annotations, typeParameters) {
    $__superConstructor(ClassExpression).call(this, location);
    this.name = name;
    this.superClass = superClass;
    this.elements = elements;
    this.annotations = annotations;
    this.typeParameters = typeParameters;
  }
  return ($__createClass)(ClassExpression, {
    transform: function(transformer) {
      return transformer.transformClassExpression(this);
    },
    visit: function(visitor) {
      visitor.visitClassExpression(this);
    },
    get type() {
      return CLASS_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var COMMA_EXPRESSION = ParseTreeType.COMMA_EXPRESSION;
var CommaExpression = function($__super) {
  function CommaExpression(location, expressions) {
    $__superConstructor(CommaExpression).call(this, location);
    this.expressions = expressions;
  }
  return ($__createClass)(CommaExpression, {
    transform: function(transformer) {
      return transformer.transformCommaExpression(this);
    },
    visit: function(visitor) {
      visitor.visitCommaExpression(this);
    },
    get type() {
      return COMMA_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var COMPREHENSION_FOR = ParseTreeType.COMPREHENSION_FOR;
var ComprehensionFor = function($__super) {
  function ComprehensionFor(location, left, iterator) {
    $__superConstructor(ComprehensionFor).call(this, location);
    this.left = left;
    this.iterator = iterator;
  }
  return ($__createClass)(ComprehensionFor, {
    transform: function(transformer) {
      return transformer.transformComprehensionFor(this);
    },
    visit: function(visitor) {
      visitor.visitComprehensionFor(this);
    },
    get type() {
      return COMPREHENSION_FOR;
    }
  }, {}, $__super);
}(ParseTree);
var COMPREHENSION_IF = ParseTreeType.COMPREHENSION_IF;
var ComprehensionIf = function($__super) {
  function ComprehensionIf(location, expression) {
    $__superConstructor(ComprehensionIf).call(this, location);
    this.expression = expression;
  }
  return ($__createClass)(ComprehensionIf, {
    transform: function(transformer) {
      return transformer.transformComprehensionIf(this);
    },
    visit: function(visitor) {
      visitor.visitComprehensionIf(this);
    },
    get type() {
      return COMPREHENSION_IF;
    }
  }, {}, $__super);
}(ParseTree);
var COMPUTED_PROPERTY_NAME = ParseTreeType.COMPUTED_PROPERTY_NAME;
var ComputedPropertyName = function($__super) {
  function ComputedPropertyName(location, expression) {
    $__superConstructor(ComputedPropertyName).call(this, location);
    this.expression = expression;
  }
  return ($__createClass)(ComputedPropertyName, {
    transform: function(transformer) {
      return transformer.transformComputedPropertyName(this);
    },
    visit: function(visitor) {
      visitor.visitComputedPropertyName(this);
    },
    get type() {
      return COMPUTED_PROPERTY_NAME;
    }
  }, {}, $__super);
}(ParseTree);
var CONDITIONAL_EXPRESSION = ParseTreeType.CONDITIONAL_EXPRESSION;
var ConditionalExpression = function($__super) {
  function ConditionalExpression(location, condition, left, right) {
    $__superConstructor(ConditionalExpression).call(this, location);
    this.condition = condition;
    this.left = left;
    this.right = right;
  }
  return ($__createClass)(ConditionalExpression, {
    transform: function(transformer) {
      return transformer.transformConditionalExpression(this);
    },
    visit: function(visitor) {
      visitor.visitConditionalExpression(this);
    },
    get type() {
      return CONDITIONAL_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var CONSTRUCT_SIGNATURE = ParseTreeType.CONSTRUCT_SIGNATURE;
var ConstructSignature = function($__super) {
  function ConstructSignature(location, typeParameters, parameterList, returnType) {
    $__superConstructor(ConstructSignature).call(this, location);
    this.typeParameters = typeParameters;
    this.parameterList = parameterList;
    this.returnType = returnType;
  }
  return ($__createClass)(ConstructSignature, {
    transform: function(transformer) {
      return transformer.transformConstructSignature(this);
    },
    visit: function(visitor) {
      visitor.visitConstructSignature(this);
    },
    get type() {
      return CONSTRUCT_SIGNATURE;
    }
  }, {}, $__super);
}(ParseTree);
var CONSTRUCTOR_TYPE = ParseTreeType.CONSTRUCTOR_TYPE;
var ConstructorType = function($__super) {
  function ConstructorType(location, typeParameters, parameterList, returnType) {
    $__superConstructor(ConstructorType).call(this, location);
    this.typeParameters = typeParameters;
    this.parameterList = parameterList;
    this.returnType = returnType;
  }
  return ($__createClass)(ConstructorType, {
    transform: function(transformer) {
      return transformer.transformConstructorType(this);
    },
    visit: function(visitor) {
      visitor.visitConstructorType(this);
    },
    get type() {
      return CONSTRUCTOR_TYPE;
    }
  }, {}, $__super);
}(ParseTree);
var CONTINUE_STATEMENT = ParseTreeType.CONTINUE_STATEMENT;
var ContinueStatement = function($__super) {
  function ContinueStatement(location, name) {
    $__superConstructor(ContinueStatement).call(this, location);
    this.name = name;
  }
  return ($__createClass)(ContinueStatement, {
    transform: function(transformer) {
      return transformer.transformContinueStatement(this);
    },
    visit: function(visitor) {
      visitor.visitContinueStatement(this);
    },
    get type() {
      return CONTINUE_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var COVER_FORMALS = ParseTreeType.COVER_FORMALS;
var CoverFormals = function($__super) {
  function CoverFormals(location, expressions) {
    $__superConstructor(CoverFormals).call(this, location);
    this.expressions = expressions;
  }
  return ($__createClass)(CoverFormals, {
    transform: function(transformer) {
      return transformer.transformCoverFormals(this);
    },
    visit: function(visitor) {
      visitor.visitCoverFormals(this);
    },
    get type() {
      return COVER_FORMALS;
    }
  }, {}, $__super);
}(ParseTree);
var COVER_INITIALIZED_NAME = ParseTreeType.COVER_INITIALIZED_NAME;
var CoverInitializedName = function($__super) {
  function CoverInitializedName(location, name, equalToken, initializer) {
    $__superConstructor(CoverInitializedName).call(this, location);
    this.name = name;
    this.equalToken = equalToken;
    this.initializer = initializer;
  }
  return ($__createClass)(CoverInitializedName, {
    transform: function(transformer) {
      return transformer.transformCoverInitializedName(this);
    },
    visit: function(visitor) {
      visitor.visitCoverInitializedName(this);
    },
    get type() {
      return COVER_INITIALIZED_NAME;
    }
  }, {}, $__super);
}(ParseTree);
var DEBUGGER_STATEMENT = ParseTreeType.DEBUGGER_STATEMENT;
var DebuggerStatement = function($__super) {
  function DebuggerStatement(location) {
    $__superConstructor(DebuggerStatement).call(this, location);
  }
  return ($__createClass)(DebuggerStatement, {
    transform: function(transformer) {
      return transformer.transformDebuggerStatement(this);
    },
    visit: function(visitor) {
      visitor.visitDebuggerStatement(this);
    },
    get type() {
      return DEBUGGER_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var DEFAULT_CLAUSE = ParseTreeType.DEFAULT_CLAUSE;
var DefaultClause = function($__super) {
  function DefaultClause(location, statements) {
    $__superConstructor(DefaultClause).call(this, location);
    this.statements = statements;
  }
  return ($__createClass)(DefaultClause, {
    transform: function(transformer) {
      return transformer.transformDefaultClause(this);
    },
    visit: function(visitor) {
      visitor.visitDefaultClause(this);
    },
    get type() {
      return DEFAULT_CLAUSE;
    }
  }, {}, $__super);
}(ParseTree);
var DO_WHILE_STATEMENT = ParseTreeType.DO_WHILE_STATEMENT;
var DoWhileStatement = function($__super) {
  function DoWhileStatement(location, body, condition) {
    $__superConstructor(DoWhileStatement).call(this, location);
    this.body = body;
    this.condition = condition;
  }
  return ($__createClass)(DoWhileStatement, {
    transform: function(transformer) {
      return transformer.transformDoWhileStatement(this);
    },
    visit: function(visitor) {
      visitor.visitDoWhileStatement(this);
    },
    get type() {
      return DO_WHILE_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var EMPTY_STATEMENT = ParseTreeType.EMPTY_STATEMENT;
var EmptyStatement = function($__super) {
  function EmptyStatement(location) {
    $__superConstructor(EmptyStatement).call(this, location);
  }
  return ($__createClass)(EmptyStatement, {
    transform: function(transformer) {
      return transformer.transformEmptyStatement(this);
    },
    visit: function(visitor) {
      visitor.visitEmptyStatement(this);
    },
    get type() {
      return EMPTY_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var EXPORT_DECLARATION = ParseTreeType.EXPORT_DECLARATION;
var ExportDeclaration = function($__super) {
  function ExportDeclaration(location, declaration, annotations) {
    $__superConstructor(ExportDeclaration).call(this, location);
    this.declaration = declaration;
    this.annotations = annotations;
  }
  return ($__createClass)(ExportDeclaration, {
    transform: function(transformer) {
      return transformer.transformExportDeclaration(this);
    },
    visit: function(visitor) {
      visitor.visitExportDeclaration(this);
    },
    get type() {
      return EXPORT_DECLARATION;
    }
  }, {}, $__super);
}(ParseTree);
var EXPORT_DEFAULT = ParseTreeType.EXPORT_DEFAULT;
var ExportDefault = function($__super) {
  function ExportDefault(location, expression) {
    $__superConstructor(ExportDefault).call(this, location);
    this.expression = expression;
  }
  return ($__createClass)(ExportDefault, {
    transform: function(transformer) {
      return transformer.transformExportDefault(this);
    },
    visit: function(visitor) {
      visitor.visitExportDefault(this);
    },
    get type() {
      return EXPORT_DEFAULT;
    }
  }, {}, $__super);
}(ParseTree);
var EXPORT_SPECIFIER = ParseTreeType.EXPORT_SPECIFIER;
var ExportSpecifier = function($__super) {
  function ExportSpecifier(location, lhs, rhs) {
    $__superConstructor(ExportSpecifier).call(this, location);
    this.lhs = lhs;
    this.rhs = rhs;
  }
  return ($__createClass)(ExportSpecifier, {
    transform: function(transformer) {
      return transformer.transformExportSpecifier(this);
    },
    visit: function(visitor) {
      visitor.visitExportSpecifier(this);
    },
    get type() {
      return EXPORT_SPECIFIER;
    }
  }, {}, $__super);
}(ParseTree);
var EXPORT_SPECIFIER_SET = ParseTreeType.EXPORT_SPECIFIER_SET;
var ExportSpecifierSet = function($__super) {
  function ExportSpecifierSet(location, specifiers) {
    $__superConstructor(ExportSpecifierSet).call(this, location);
    this.specifiers = specifiers;
  }
  return ($__createClass)(ExportSpecifierSet, {
    transform: function(transformer) {
      return transformer.transformExportSpecifierSet(this);
    },
    visit: function(visitor) {
      visitor.visitExportSpecifierSet(this);
    },
    get type() {
      return EXPORT_SPECIFIER_SET;
    }
  }, {}, $__super);
}(ParseTree);
var EXPORT_STAR = ParseTreeType.EXPORT_STAR;
var ExportStar = function($__super) {
  function ExportStar(location) {
    $__superConstructor(ExportStar).call(this, location);
  }
  return ($__createClass)(ExportStar, {
    transform: function(transformer) {
      return transformer.transformExportStar(this);
    },
    visit: function(visitor) {
      visitor.visitExportStar(this);
    },
    get type() {
      return EXPORT_STAR;
    }
  }, {}, $__super);
}(ParseTree);
var EXPRESSION_STATEMENT = ParseTreeType.EXPRESSION_STATEMENT;
var ExpressionStatement = function($__super) {
  function ExpressionStatement(location, expression) {
    $__superConstructor(ExpressionStatement).call(this, location);
    this.expression = expression;
  }
  return ($__createClass)(ExpressionStatement, {
    transform: function(transformer) {
      return transformer.transformExpressionStatement(this);
    },
    visit: function(visitor) {
      visitor.visitExpressionStatement(this);
    },
    get type() {
      return EXPRESSION_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var FINALLY = ParseTreeType.FINALLY;
var Finally = function($__super) {
  function Finally(location, block) {
    $__superConstructor(Finally).call(this, location);
    this.block = block;
  }
  return ($__createClass)(Finally, {
    transform: function(transformer) {
      return transformer.transformFinally(this);
    },
    visit: function(visitor) {
      visitor.visitFinally(this);
    },
    get type() {
      return FINALLY;
    }
  }, {}, $__super);
}(ParseTree);
var FOR_IN_STATEMENT = ParseTreeType.FOR_IN_STATEMENT;
var ForInStatement = function($__super) {
  function ForInStatement(location, initializer, collection, body) {
    $__superConstructor(ForInStatement).call(this, location);
    this.initializer = initializer;
    this.collection = collection;
    this.body = body;
  }
  return ($__createClass)(ForInStatement, {
    transform: function(transformer) {
      return transformer.transformForInStatement(this);
    },
    visit: function(visitor) {
      visitor.visitForInStatement(this);
    },
    get type() {
      return FOR_IN_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var FOR_OF_STATEMENT = ParseTreeType.FOR_OF_STATEMENT;
var ForOfStatement = function($__super) {
  function ForOfStatement(location, initializer, collection, body) {
    $__superConstructor(ForOfStatement).call(this, location);
    this.initializer = initializer;
    this.collection = collection;
    this.body = body;
  }
  return ($__createClass)(ForOfStatement, {
    transform: function(transformer) {
      return transformer.transformForOfStatement(this);
    },
    visit: function(visitor) {
      visitor.visitForOfStatement(this);
    },
    get type() {
      return FOR_OF_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var FOR_ON_STATEMENT = ParseTreeType.FOR_ON_STATEMENT;
var ForOnStatement = function($__super) {
  function ForOnStatement(location, initializer, observable, body) {
    $__superConstructor(ForOnStatement).call(this, location);
    this.initializer = initializer;
    this.observable = observable;
    this.body = body;
  }
  return ($__createClass)(ForOnStatement, {
    transform: function(transformer) {
      return transformer.transformForOnStatement(this);
    },
    visit: function(visitor) {
      visitor.visitForOnStatement(this);
    },
    get type() {
      return FOR_ON_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var FOR_STATEMENT = ParseTreeType.FOR_STATEMENT;
var ForStatement = function($__super) {
  function ForStatement(location, initializer, condition, increment, body) {
    $__superConstructor(ForStatement).call(this, location);
    this.initializer = initializer;
    this.condition = condition;
    this.increment = increment;
    this.body = body;
  }
  return ($__createClass)(ForStatement, {
    transform: function(transformer) {
      return transformer.transformForStatement(this);
    },
    visit: function(visitor) {
      visitor.visitForStatement(this);
    },
    get type() {
      return FOR_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var FORMAL_PARAMETER = ParseTreeType.FORMAL_PARAMETER;
var FormalParameter = function($__super) {
  function FormalParameter(location, parameter, typeAnnotation, annotations) {
    $__superConstructor(FormalParameter).call(this, location);
    this.parameter = parameter;
    this.typeAnnotation = typeAnnotation;
    this.annotations = annotations;
  }
  return ($__createClass)(FormalParameter, {
    transform: function(transformer) {
      return transformer.transformFormalParameter(this);
    },
    visit: function(visitor) {
      visitor.visitFormalParameter(this);
    },
    get type() {
      return FORMAL_PARAMETER;
    }
  }, {}, $__super);
}(ParseTree);
var FORMAL_PARAMETER_LIST = ParseTreeType.FORMAL_PARAMETER_LIST;
var FormalParameterList = function($__super) {
  function FormalParameterList(location, parameters) {
    $__superConstructor(FormalParameterList).call(this, location);
    this.parameters = parameters;
  }
  return ($__createClass)(FormalParameterList, {
    transform: function(transformer) {
      return transformer.transformFormalParameterList(this);
    },
    visit: function(visitor) {
      visitor.visitFormalParameterList(this);
    },
    get type() {
      return FORMAL_PARAMETER_LIST;
    }
  }, {}, $__super);
}(ParseTree);
var FORWARD_DEFAULT_EXPORT = ParseTreeType.FORWARD_DEFAULT_EXPORT;
var ForwardDefaultExport = function($__super) {
  function ForwardDefaultExport(location, name) {
    $__superConstructor(ForwardDefaultExport).call(this, location);
    this.name = name;
  }
  return ($__createClass)(ForwardDefaultExport, {
    transform: function(transformer) {
      return transformer.transformForwardDefaultExport(this);
    },
    visit: function(visitor) {
      visitor.visitForwardDefaultExport(this);
    },
    get type() {
      return FORWARD_DEFAULT_EXPORT;
    }
  }, {}, $__super);
}(ParseTree);
var FUNCTION_BODY = ParseTreeType.FUNCTION_BODY;
var FunctionBody = function($__super) {
  function FunctionBody(location, statements) {
    $__superConstructor(FunctionBody).call(this, location);
    this.statements = statements;
  }
  return ($__createClass)(FunctionBody, {
    transform: function(transformer) {
      return transformer.transformFunctionBody(this);
    },
    visit: function(visitor) {
      visitor.visitFunctionBody(this);
    },
    get type() {
      return FUNCTION_BODY;
    }
  }, {}, $__super);
}(ParseTree);
var FUNCTION_DECLARATION = ParseTreeType.FUNCTION_DECLARATION;
var FunctionDeclaration = function($__super) {
  function FunctionDeclaration(location, name, functionKind, parameterList, typeAnnotation, annotations, body) {
    $__superConstructor(FunctionDeclaration).call(this, location);
    this.name = name;
    this.functionKind = functionKind;
    this.parameterList = parameterList;
    this.typeAnnotation = typeAnnotation;
    this.annotations = annotations;
    this.body = body;
  }
  return ($__createClass)(FunctionDeclaration, {
    transform: function(transformer) {
      return transformer.transformFunctionDeclaration(this);
    },
    visit: function(visitor) {
      visitor.visitFunctionDeclaration(this);
    },
    get type() {
      return FUNCTION_DECLARATION;
    }
  }, {}, $__super);
}(ParseTree);
var FUNCTION_EXPRESSION = ParseTreeType.FUNCTION_EXPRESSION;
var FunctionExpression = function($__super) {
  function FunctionExpression(location, name, functionKind, parameterList, typeAnnotation, annotations, body) {
    $__superConstructor(FunctionExpression).call(this, location);
    this.name = name;
    this.functionKind = functionKind;
    this.parameterList = parameterList;
    this.typeAnnotation = typeAnnotation;
    this.annotations = annotations;
    this.body = body;
  }
  return ($__createClass)(FunctionExpression, {
    transform: function(transformer) {
      return transformer.transformFunctionExpression(this);
    },
    visit: function(visitor) {
      visitor.visitFunctionExpression(this);
    },
    get type() {
      return FUNCTION_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var FUNCTION_TYPE = ParseTreeType.FUNCTION_TYPE;
var FunctionType = function($__super) {
  function FunctionType(location, typeParameters, parameterList, returnType) {
    $__superConstructor(FunctionType).call(this, location);
    this.typeParameters = typeParameters;
    this.parameterList = parameterList;
    this.returnType = returnType;
  }
  return ($__createClass)(FunctionType, {
    transform: function(transformer) {
      return transformer.transformFunctionType(this);
    },
    visit: function(visitor) {
      visitor.visitFunctionType(this);
    },
    get type() {
      return FUNCTION_TYPE;
    }
  }, {}, $__super);
}(ParseTree);
var GENERATOR_COMPREHENSION = ParseTreeType.GENERATOR_COMPREHENSION;
var GeneratorComprehension = function($__super) {
  function GeneratorComprehension(location, comprehensionList, expression) {
    $__superConstructor(GeneratorComprehension).call(this, location);
    this.comprehensionList = comprehensionList;
    this.expression = expression;
  }
  return ($__createClass)(GeneratorComprehension, {
    transform: function(transformer) {
      return transformer.transformGeneratorComprehension(this);
    },
    visit: function(visitor) {
      visitor.visitGeneratorComprehension(this);
    },
    get type() {
      return GENERATOR_COMPREHENSION;
    }
  }, {}, $__super);
}(ParseTree);
var GET_ACCESSOR = ParseTreeType.GET_ACCESSOR;
var GetAccessor = function($__super) {
  function GetAccessor(location, isStatic, name, typeAnnotation, annotations, body) {
    $__superConstructor(GetAccessor).call(this, location);
    this.isStatic = isStatic;
    this.name = name;
    this.typeAnnotation = typeAnnotation;
    this.annotations = annotations;
    this.body = body;
  }
  return ($__createClass)(GetAccessor, {
    transform: function(transformer) {
      return transformer.transformGetAccessor(this);
    },
    visit: function(visitor) {
      visitor.visitGetAccessor(this);
    },
    get type() {
      return GET_ACCESSOR;
    }
  }, {}, $__super);
}(ParseTree);
var IDENTIFIER_EXPRESSION = ParseTreeType.IDENTIFIER_EXPRESSION;
var IdentifierExpression = function($__super) {
  function IdentifierExpression(location, identifierToken) {
    $__superConstructor(IdentifierExpression).call(this, location);
    this.identifierToken = identifierToken;
  }
  return ($__createClass)(IdentifierExpression, {
    transform: function(transformer) {
      return transformer.transformIdentifierExpression(this);
    },
    visit: function(visitor) {
      visitor.visitIdentifierExpression(this);
    },
    get type() {
      return IDENTIFIER_EXPRESSION;
    }
  }, {}, $__super);
}(ParseTree);
var IF_STATEMENT = ParseTreeType.IF_STATEMENT;
var IfStatement = function($__super) {
  function IfStatement(location, condition, ifClause, elseClause) {
    $__superConstructor(IfStatement).call(this, location);
    this.condition = condition;
    this.ifClause = ifClause;
    this.elseClause = elseClause;
  }
  return ($__createClass)(IfStatement, {
    transform: function(transformer) {
      return transformer.transformIfStatement(this);
    },
    visit: function(visitor) {
      visitor.visitIfStatement(this);
    },
    get type() {
      return IF_STATEMENT;
    }
  }, {}, $__super);
}(ParseTree);
var IMPORTED_BINDING = ParseTreeType.IMPORTED_BINDING;
var ImportedBinding = function($__super) {
  function ImportedBinding(location, binding) {
    $__superConstructor(ImportedBinding).call(this, location);
    this.binding = binding;
  }
  return ($__createClass)(ImportedBinding, {
    transform: function(transformer) {
      return transformer.transformImportedBinding(this);
    },
    visit: function(visitor) {
      visitor.visitImportedBinding(this);
    },
    get type() {
      return IMPORTED_BINDING;
    }
  }, {}, $__super);
}(ParseTree);
var IMPORT_CLAUSE_PAIR = ParseTreeType.IMPORT_CLAUSE_PAIR;
var ImportClausePair = function($__super) {
  function ImportClausePair(location, first, second) {
    $__superConstructor(ImportClausePair).call(this, location);
    this.first = first;
    this.second = second;
  }
  return ($__createClass)(ImportClausePair, {
    transform: function(transformer) {
      return transformer.transformImportClausePair(this);
    },
    visit: function(visitor) {
      visitor.visitImportClausePair(this);
    },
    get type() {
      return IMPORT_CLAUSE_PAIR;
    }
  }, {}, $__super);
}(ParseTree);
var IMPORT_DECLARATION = ParseTreeType.IMPORT_DECLARATION;
var ImportDeclaration = function($__super) {
  function ImportDeclaration(location, importClause, moduleSpecifier) {
    $__superConstructor(ImportDeclaration).call(this, location);
    this.importClause = importClause;
    this.moduleSpecifier = moduleSpecifier;
  }
  return ($__createClass)(ImportDeclaration, {
    transform: function(transformer) {
      return transformer.transformImportDeclaration(this);
    },
    visit: function(visitor) {
      visitor.visitImportDeclaration(this);
    },
    get type() {
      return IMPORT_DECLARATION;
    }
  }, {}, $__super);
}(ParseTree);
var IMPORT_SPECIFIER = ParseTreeType.IMPORT_SPECIFIER;
var ImportSpecifi