hermes-estree 0.10.1 → 0.11.0

package/dist/generated/predicates.js

@@ -72,13 +72,20 @@ exports.isClosingCurlyBracketToken = isClosingCurlyBracketToken;
 exports.isClosingParenthesisToken = isClosingParenthesisToken;
 exports.isColonToken = isColonToken;
 exports.isCommaToken = isCommaToken;
+exports.isComponentDeclaration = isComponentDeclaration;
+exports.isComponentParameter = isComponentParameter;
+exports.isComponentTypeAnnotation = isComponentTypeAnnotation;
+exports.isComponentTypeParameter = isComponentTypeParameter;
 exports.isConditionalExpression = isConditionalExpression;
+exports.isConditionalTypeAnnotation = isConditionalTypeAnnotation;
 exports.isConstToken = isConstToken;
 exports.isContinueStatement = isContinueStatement;
 exports.isContinueToken = isContinueToken;
 exports.isDebuggerStatement = isDebuggerStatement;
 exports.isDebuggerToken = isDebuggerToken;
 exports.isDeclareClass = isDeclareClass;
+exports.isDeclareComponent = isDeclareComponent;
+exports.isDeclareEnum = isDeclareEnum;
 exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
 exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
 exports.isDeclareFunction = isDeclareFunction;
@@ -152,6 +159,7 @@ exports.isImportToken = isImportToken;
 exports.isInToken = isInToken;
 exports.isIncrementToken = isIncrementToken;
 exports.isIndexedAccessType = isIndexedAccessType;
+exports.isInferTypeAnnotation = isInferTypeAnnotation;
 exports.isInferredPredicate = isInferredPredicate;
 exports.isInstanceOfToken = isInstanceOfToken;
 exports.isInterfaceDeclaration = isInterfaceDeclaration;
@@ -175,6 +183,7 @@ exports.isJSXOpeningFragment = isJSXOpeningFragment;
 exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
 exports.isJSXSpreadChild = isJSXSpreadChild;
 exports.isJSXText = isJSXText;
+exports.isKeyofTypeAnnotation = isKeyofTypeAnnotation;
 exports.isLabeledStatement = isLabeledStatement;
 exports.isLessThanOrEqualToToken = isLessThanOrEqualToToken;
 exports.isLessThanToken = isLessThanToken;
@@ -211,6 +220,7 @@ exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
 exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
 exports.isObjectTypeIndexer = isObjectTypeIndexer;
 exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
+exports.isObjectTypeMappedTypeProperty = isObjectTypeMappedTypeProperty;
 exports.isObjectTypeProperty = isObjectTypeProperty;
 exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
 exports.isOfKeyword = isOfKeyword;
@@ -227,6 +237,7 @@ exports.isPrivateIdentifier = isPrivateIdentifier;
 exports.isProperty = isProperty;
 exports.isPropertyDefinition = isPropertyDefinition;
 exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
+exports.isQualifiedTypeofIdentifier = isQualifiedTypeofIdentifier;
 exports.isQuestionMarkToken = isQuestionMarkToken;
 exports.isRemainderEqualToken = isRemainderEqualToken;
 exports.isRestElement = isRestElement;
@@ -258,6 +269,8 @@ exports.isThrowToken = isThrowToken;
 exports.isTryStatement = isTryStatement;
 exports.isTryToken = isTryToken;
 exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
+exports.isTupleTypeLabeledElement = isTupleTypeLabeledElement;
+exports.isTupleTypeSpreadElement = isTupleTypeSpreadElement;
 exports.isTypeAlias = isTypeAlias;
 exports.isTypeAnnotation = isTypeAnnotation;
 exports.isTypeCastExpression = isTypeCastExpression;
@@ -266,6 +279,7 @@ exports.isTypeOfToken = isTypeOfToken;
 exports.isTypeParameter = isTypeParameter;
 exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
 exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
+exports.isTypePredicate = isTypePredicate;
 exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
 exports.isUnaryExpression = isUnaryExpression;
 exports.isUnaryNegationToken = isUnaryNegationToken;
@@ -373,10 +387,30 @@ function isClassImplements(node) {
   return node.type === 'ClassImplements';
 }
 
+function isComponentDeclaration(node) {
+  return node.type === 'ComponentDeclaration';
+}
+
+function isComponentParameter(node) {
+  return node.type === 'ComponentParameter';
+}
+
+function isComponentTypeAnnotation(node) {
+  return node.type === 'ComponentTypeAnnotation';
+}
+
+function isComponentTypeParameter(node) {
+  return node.type === 'ComponentTypeParameter';
+}
+
 function isConditionalExpression(node) {
   return node.type === 'ConditionalExpression';
 }
 
+function isConditionalTypeAnnotation(node) {
+  return node.type === 'ConditionalTypeAnnotation';
+}
+
 function isContinueStatement(node) {
   return node.type === 'ContinueStatement';
 }
@@ -389,10 +423,18 @@ function isDeclareClass(node) {
   return node.type === 'DeclareClass';
 }
 
+function isDeclareComponent(node) {
+  return node.type === 'DeclareComponent';
+}
+
 function isDeclaredPredicate(node) {
   return node.type === 'DeclaredPredicate';
 }
 
+function isDeclareEnum(node) {
+  return node.type === 'DeclareEnum';
+}
+
 function isDeclareExportAllDeclaration(node) {
   return node.type === 'DeclareExportAllDeclaration';
 }
@@ -573,6 +615,10 @@ function isInferredPredicate(node) {
   return node.type === 'InferredPredicate';
 }
 
+function isInferTypeAnnotation(node) {
+  return node.type === 'InferTypeAnnotation';
+}
+
 function isInterfaceDeclaration(node) {
   return node.type === 'InterfaceDeclaration';
 }
@@ -649,6 +695,10 @@ function isJSXText(node) {
   return node.type === 'JSXText';
 }
 
+function isKeyofTypeAnnotation(node) {
+  return node.type === 'KeyofTypeAnnotation';
+}
+
 function isLabeledStatement(node) {
   return node.type === 'LabeledStatement';
 }
@@ -717,6 +767,10 @@ function isObjectTypeInternalSlot(node) {
   return node.type === 'ObjectTypeInternalSlot';
 }
 
+function isObjectTypeMappedTypeProperty(node) {
+  return node.type === 'ObjectTypeMappedTypeProperty';
+}
+
 function isObjectTypeProperty(node) {
   return node.type === 'ObjectTypeProperty';
 }
@@ -749,6 +803,10 @@ function isQualifiedTypeIdentifier(node) {
   return node.type === 'QualifiedTypeIdentifier';
 }
 
+function isQualifiedTypeofIdentifier(node) {
+  return node.type === 'QualifiedTypeofIdentifier';
+}
+
 function isRestElement(node) {
   return node.type === 'RestElement';
 }
@@ -821,6 +879,14 @@ function isTupleTypeAnnotation(node) {
   return node.type === 'TupleTypeAnnotation';
 }
 
+function isTupleTypeLabeledElement(node) {
+  return node.type === 'TupleTypeLabeledElement';
+}
+
+function isTupleTypeSpreadElement(node) {
+  return node.type === 'TupleTypeSpreadElement';
+}
+
 function isTypeAlias(node) {
   return node.type === 'TypeAlias';
 }
@@ -849,6 +915,10 @@ function isTypeParameterInstantiation(node) {
   return node.type === 'TypeParameterInstantiation';
 }
 
+function isTypePredicate(node) {
+  return node.type === 'TypePredicate';
+}
+
 function isUnaryExpression(node) {
   return node.type === 'UnaryExpression';
 }

package/dist/generated/predicates.js.flow

@@ -117,10 +117,36 @@ export function isClassImplements(node: ESNode | Token): boolean %checks {
   return node.type === 'ClassImplements';
 }
 
+export function isComponentDeclaration(node: ESNode | Token): boolean %checks {
+  return node.type === 'ComponentDeclaration';
+}
+
+export function isComponentParameter(node: ESNode | Token): boolean %checks {
+  return node.type === 'ComponentParameter';
+}
+
+export function isComponentTypeAnnotation(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ComponentTypeAnnotation';
+}
+
+export function isComponentTypeParameter(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ComponentTypeParameter';
+}
+
 export function isConditionalExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'ConditionalExpression';
 }
 
+export function isConditionalTypeAnnotation(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ConditionalTypeAnnotation';
+}
+
 export function isContinueStatement(node: ESNode | Token): boolean %checks {
   return node.type === 'ContinueStatement';
 }
@@ -133,10 +159,18 @@ export function isDeclareClass(node: ESNode | Token): boolean %checks {
   return node.type === 'DeclareClass';
 }
 
+export function isDeclareComponent(node: ESNode | Token): boolean %checks {
+  return node.type === 'DeclareComponent';
+}
+
 export function isDeclaredPredicate(node: ESNode | Token): boolean %checks {
   return node.type === 'DeclaredPredicate';
 }
 
+export function isDeclareEnum(node: ESNode | Token): boolean %checks {
+  return node.type === 'DeclareEnum';
+}
+
 export function isDeclareExportAllDeclaration(
   node: ESNode | Token,
 ): boolean %checks {
@@ -331,6 +365,10 @@ export function isInferredPredicate(node: ESNode | Token): boolean %checks {
   return node.type === 'InferredPredicate';
 }
 
+export function isInferTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'InferTypeAnnotation';
+}
+
 export function isInterfaceDeclaration(node: ESNode | Token): boolean %checks {
   return node.type === 'InterfaceDeclaration';
 }
@@ -413,6 +451,10 @@ export function isJSXText(node: ESNode | Token): boolean %checks {
   return node.type === 'JSXText';
 }
 
+export function isKeyofTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'KeyofTypeAnnotation';
+}
+
 export function isLabeledStatement(node: ESNode | Token): boolean %checks {
   return node.type === 'LabeledStatement';
 }
@@ -491,6 +533,12 @@ export function isObjectTypeInternalSlot(
   return node.type === 'ObjectTypeInternalSlot';
 }
 
+export function isObjectTypeMappedTypeProperty(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'ObjectTypeMappedTypeProperty';
+}
+
 export function isObjectTypeProperty(node: ESNode | Token): boolean %checks {
   return node.type === 'ObjectTypeProperty';
 }
@@ -529,6 +577,12 @@ export function isQualifiedTypeIdentifier(
   return node.type === 'QualifiedTypeIdentifier';
 }
 
+export function isQualifiedTypeofIdentifier(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'QualifiedTypeofIdentifier';
+}
+
 export function isRestElement(node: ESNode | Token): boolean %checks {
   return node.type === 'RestElement';
 }
@@ -605,6 +659,18 @@ export function isTupleTypeAnnotation(node: ESNode | Token): boolean %checks {
   return node.type === 'TupleTypeAnnotation';
 }
 
+export function isTupleTypeLabeledElement(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'TupleTypeLabeledElement';
+}
+
+export function isTupleTypeSpreadElement(
+  node: ESNode | Token,
+): boolean %checks {
+  return node.type === 'TupleTypeSpreadElement';
+}
+
 export function isTypeAlias(node: ESNode | Token): boolean %checks {
   return node.type === 'TypeAlias';
 }
@@ -637,6 +703,10 @@ export function isTypeParameterInstantiation(
   return node.type === 'TypeParameterInstantiation';
 }
 
+export function isTypePredicate(node: ESNode | Token): boolean %checks {
+  return node.type === 'TypePredicate';
+}
+
 export function isUnaryExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'UnaryExpression';
 }

package/dist/types.js.flow

@@ -174,17 +174,21 @@ export type ESNode =
   | TypeAnnotationType
   | Variance
   | FunctionTypeParam
+  | ComponentTypeParameter
   | InferredPredicate
   | ObjectTypeProperty
   | ObjectTypeCallProperty
   | ObjectTypeIndexer
   | ObjectTypeSpreadProperty
+  | ObjectTypeMappedTypeProperty
   | InterfaceExtends
   | ClassImplements
   | Decorator
   | TypeParameterDeclaration
   | TypeParameter
   | TypeParameterInstantiation
+  | ComponentDeclaration
+  | ComponentParameter
   | EnumDeclaration
   | EnumNumberBody
   | EnumStringBody
@@ -227,10 +231,13 @@ export type Statement =
   | BlockStatement
   | BreakStatement
   | ClassDeclaration
+  | ComponentDeclaration
   | ContinueStatement
   | DebuggerStatement
   | DeclareClass
+  | DeclareComponent
   | DeclareVariable
+  | DeclareEnum
   | DeclareFunction
   | DeclareInterface
   | DeclareModule
@@ -377,6 +384,24 @@ export interface DebuggerStatement extends BaseNode {
   +type: 'DebuggerStatement';
 }
 
+type ComponentParameterAndRestElement = ComponentParameter | RestElement;
+
+export interface ComponentParameter extends BaseNode {
+  +type: 'ComponentParameter';
+  +name: Identifier | StringLiteral;
+  +local: BindingName | AssignmentPattern;
+  +shorthand: boolean;
+}
+
+export interface ComponentDeclaration extends BaseNode {
+  +type: 'ComponentDeclaration';
+  +body: BlockStatement;
+  +id: Identifier;
+  +params: $ReadOnlyArray<ComponentParameterAndRestElement>;
+  +returnType: null | TypeAnnotation;
+  +typeParameters: null | TypeParameterDeclaration;
+}
+
 export interface FunctionDeclaration extends BaseFunction {
   +type: 'FunctionDeclaration';
   /** It is null when a function declaration is a part of the `export default function` statement */
@@ -619,7 +644,6 @@ export type MemberExpression =
   | MemberExpressionWithNonComputedName;
 export interface MemberExpressionWithComputedName extends BaseNode {
   +type: 'MemberExpression';
-  +computed: true;
   +object: Expression | Super;
   +property: Expression;
   +computed: true;
@@ -627,7 +651,6 @@ export interface MemberExpressionWithComputedName extends BaseNode {
 }
 export interface MemberExpressionWithNonComputedName extends BaseNode {
   +type: 'MemberExpression';
-  +computed: false;
   +object: Expression | Super;
   +property: Identifier | PrivateIdentifier;
   +computed: false;
@@ -1021,7 +1044,10 @@ export interface ImportNamespaceSpecifier extends BaseNode {
   +parent: ImportDeclaration;
 }
 
-export type DefaultDeclaration = FunctionDeclaration | ClassDeclaration;
+export type DefaultDeclaration =
+  | FunctionDeclaration
+  | ClassDeclaration
+  | ComponentDeclaration;
 export type NamedDeclaration =
   | DefaultDeclaration
   | VariableDeclaration
@@ -1103,12 +1129,20 @@ export type TypeAnnotationType =
   | ExistsTypeAnnotation
   | GenericTypeAnnotation
   | QualifiedTypeIdentifier
+  | QualifiedTypeofIdentifier
   | TypeofTypeAnnotation
+  | KeyofTypeAnnotation
   | TupleTypeAnnotation
+  | TupleTypeSpreadElement
+  | TupleTypeLabeledElement
+  | InferTypeAnnotation
   | InterfaceTypeAnnotation
   | UnionTypeAnnotation
   | IntersectionTypeAnnotation
+  | ConditionalTypeAnnotation
+  | TypePredicate
   | FunctionTypeAnnotation
+  | ComponentTypeAnnotation
   | ObjectTypeAnnotation
   | IndexedAccessType
   | OptionalIndexedAccessType;
@@ -1218,14 +1252,40 @@ export interface QualifiedTypeIdentifier extends BaseNode {
   +id: Identifier;
   +qualification: QualifiedTypeIdentifier | Identifier;
 }
+export interface QualifiedTypeofIdentifier extends BaseNode {
+  +type: 'QualifiedTypeofIdentifier';
+  +id: Identifier;
+  +qualification: QualifiedTypeofIdentifier | Identifier;
+}
 export interface TypeofTypeAnnotation extends BaseNode {
   +type: 'TypeofTypeAnnotation';
+  +argument: QualifiedTypeofIdentifier | Identifier;
+}
+export interface KeyofTypeAnnotation extends BaseNode {
+  +type: 'KeyofTypeAnnotation';
   +argument: TypeAnnotationType;
 }
 export interface TupleTypeAnnotation extends BaseNode {
   +type: 'TupleTypeAnnotation';
   +types: $ReadOnlyArray<TypeAnnotationType>;
 }
+export interface TupleTypeSpreadElement extends BaseNode {
+  +type: 'TupleTypeSpreadElement';
+  +label?: Identifier | null;
+  +typeAnnotation: TypeAnnotationType;
+}
+export interface TupleTypeLabeledElement extends BaseNode {
+  +type: 'TupleTypeLabeledElement';
+  +label: Identifier;
+  +elementType: TypeAnnotationType;
+  +optional: boolean;
+  +variance: Variance | null;
+}
+
+export interface InferTypeAnnotation extends BaseNode {
+  +type: 'InferTypeAnnotation';
+  +typeParameter: TypeParameter;
+}
 
 // type T = { [[foo]]: number };
 export interface ObjectTypeInternalSlot extends BaseNode {
@@ -1252,6 +1312,21 @@ export interface IntersectionTypeAnnotation extends BaseNode {
   +types: $ReadOnlyArray<TypeAnnotationType>;
 }
 
+export interface ConditionalTypeAnnotation extends BaseNode {
+  +type: 'ConditionalTypeAnnotation';
+  +checkType: TypeAnnotationType;
+  +extendsType: TypeAnnotationType;
+  +trueType: TypeAnnotationType;
+  +falseType: TypeAnnotationType;
+}
+
+export interface TypePredicate extends BaseNode {
+  +type: 'TypePredicate';
+  +parameterName: Identifier;
+  +typeAnnotation: TypeAnnotationType | null;
+  +asserts: boolean;
+}
+
 export interface FunctionTypeAnnotation extends BaseNode {
   +type: 'FunctionTypeAnnotation';
   +params: $ReadOnlyArray<FunctionTypeParam>;
@@ -1268,6 +1343,23 @@ export interface FunctionTypeParam extends BaseNode {
 
   +parent: FunctionTypeAnnotation;
 }
+
+export interface ComponentTypeAnnotation extends BaseNode {
+  +type: 'ComponentTypeAnnotation';
+  +params: $ReadOnlyArray<ComponentTypeParameter>;
+  +rest: null | ComponentTypeParameter;
+  +typeParameters: null | TypeParameterDeclaration;
+  +returnType: null | TypeAnnotationType;
+}
+export interface ComponentTypeParameter extends BaseNode {
+  +type: 'ComponentTypeParameter';
+  +name: Identifier | StringLiteral | null;
+  +typeAnnotation: TypeAnnotationType | null;
+  +optional: boolean;
+
+  +parent: ComponentTypeAnnotation | DeclareComponent;
+}
+
 export interface InferredPredicate extends BaseNode {
   +type: 'InferredPredicate';
 
@@ -1278,7 +1370,11 @@ export interface ObjectTypeAnnotation extends BaseNode {
   +type: 'ObjectTypeAnnotation';
   +inexact: false;
   +exact: boolean;
-  +properties: $ReadOnlyArray<ObjectTypeProperty | ObjectTypeSpreadProperty>;
+  +properties: $ReadOnlyArray<
+    | ObjectTypeProperty
+    | ObjectTypeSpreadProperty
+    | ObjectTypeMappedTypeProperty,
+  >;
   +indexers: $ReadOnlyArray<ObjectTypeIndexer>;
   +callProperties: $ReadOnlyArray<ObjectTypeCallProperty>;
   +internalSlots: $ReadOnlyArray<ObjectTypeInternalSlot>;
@@ -1348,6 +1444,17 @@ export interface ObjectTypeIndexer extends BaseNode {
 
   +parent: ObjectTypeAnnotation;
 }
+export interface ObjectTypeMappedTypeProperty extends BaseNode {
+  +type: 'ObjectTypeMappedTypeProperty';
+  +keyTparam: TypeParameter;
+  +propType: TypeAnnotationType;
+  +sourceType: TypeAnnotationType;
+  +variance: null | Variance;
+  +optional: null | 'PlusOptional' | 'MinusOptional' | 'Optional';
+
+  +parent: ObjectTypeAnnotation;
+}
+
 export interface ObjectTypeSpreadProperty extends BaseNode {
   +type: 'ObjectTypeSpreadProperty';
   +argument: TypeAnnotationType;
@@ -1511,7 +1618,9 @@ export interface EnumDefaultedMember extends BaseNode {
 
 export type DeclaredNode =
   | DeclareClass
+  | DeclareComponent
   | DeclareVariable
+  | DeclareEnum
   | DeclareFunction
   | DeclareModule
   | DeclareInterface
@@ -1532,9 +1641,25 @@ export interface DeclareClass extends BaseNode {
   +mixins: $ReadOnlyArray<InterfaceExtends>;
 }
 
+export interface DeclareComponent extends BaseNode {
+  +type: 'DeclareComponent';
+  +id: Identifier;
+  +params: Array<ComponentTypeParameter>;
+  +rest: null | ComponentTypeParameter;
+  +typeParameters: null | TypeParameterDeclaration;
+  +returnType: null | TypeAnnotation;
+}
+
 export interface DeclareVariable extends BaseNode {
   +type: 'DeclareVariable';
   +id: Identifier;
+  +kind: 'var' | 'let' | 'const';
+}
+
+export interface DeclareEnum extends BaseNode {
+  +type: 'DeclareEnum';
+  +id: Identifier;
+  +body: EnumNumberBody | EnumStringBody | EnumBooleanBody | EnumSymbolBody;
 }
 
 export interface DeclareFunction extends BaseNode {
@@ -1597,7 +1722,8 @@ export interface DeclareExportDeclarationNamedWithDeclaration
     | DeclareFunction
     | DeclareInterface
     | DeclareOpaqueType
-    | DeclareVariable;
+    | DeclareVariable
+    | DeclareEnum;
   +default: false;
   +source: null;
   // default cannot have specifiers and a declaration
@@ -1726,6 +1852,7 @@ export interface JSXOpeningElement extends BaseNode {
   +selfClosing: boolean;
   +name: JSXTagNameExpression;
   +attributes: $ReadOnlyArray<JSXAttribute | JSXSpreadAttribute>;
+  +typeArguments?: TypeParameterInstantiation | null;
 
   +parent: JSXElement;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-estree",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
   "main": "dist/index.js",
   "license": "MIT",

package/dist/HermesAST.js.flow

@@ -1,57 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow strict
- * @format
- */
-
-// flowlint unclear-type:off
-
-export interface HermesPosition {
-  /** >= 1 */
-  +line: number;
-  /** >= 0 */
-  +column: number;
-}
-export type HermesSourceLocation = {
-  start?: HermesPosition,
-  end?: HermesPosition,
-  rangeStart?: number,
-  rangeEnd?: number,
-};
-export type HermesNode = {
-  type: string,
-  [string]: any,
-};
-export type HermesToken = {
-  type:
-    | 'Boolean'
-    | 'Identifier'
-    | 'Keyword'
-    | 'Null'
-    | 'Numeric'
-    | 'BigInt'
-    | 'Punctuator'
-    | 'String'
-    | 'RegularExpression'
-    | 'Template'
-    | 'JSXText',
-  loc: HermesSourceLocation,
-  value: ?string,
-};
-export type HermesComment = {
-  type: 'CommentLine' | 'CommentBlock' | 'InterpreterDirective',
-  loc: HermesSourceLocation,
-  value: ?string,
-};
-export type HermesProgram = {
-  type: 'Program',
-  loc: HermesSourceLocation,
-  body: Array<?HermesNode>,
-  comments: Array<HermesComment>,
-  tokens?: Array<HermesToken>,
-  interpreter?: ?HermesComment,
-};