hermes-estree 0.9.0 → 0.10.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -6,6 +6,13 @@
  *
  * @flow strict
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 
 // lint directives to let us do some basic validation of generated files
@@ -25,6 +32,7 @@ import type {
   AssignmentPattern,
   AwaitExpression,
   BigIntLiteralTypeAnnotation,
+  BigIntTypeAnnotation,
   BinaryExpression,
   BlockStatement,
   BooleanLiteralTypeAnnotation,
@@ -1044,6 +1052,9 @@ interface PropertyDefinition_With_variance extends PropertyDefinition {
 interface PropertyDefinition_With_typeAnnotation extends PropertyDefinition {
   +typeAnnotation: $NonMaybeType<PropertyDefinition['typeAnnotation']>;
 }
+interface PropertyDefinition_With_tsModifiers extends PropertyDefinition {
+  +tsModifiers: $NonMaybeType<PropertyDefinition['tsModifiers']>;
+}
 interface QualifiedTypeIdentifier_With_qualification
   extends QualifiedTypeIdentifier {
   +qualification: $NonMaybeType<QualifiedTypeIdentifier['qualification']>;
@@ -1341,6 +1352,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'BigIntLiteralTypeAnnotation[raw]'?: (
     node: BigIntLiteralTypeAnnotation_With_raw,
   ) => void,
+  +BigIntTypeAnnotation?: (node: BigIntTypeAnnotation) => void,
   +BinaryExpression?: (node: BinaryExpression) => void,
   +'BinaryExpression[left]'?: (node: BinaryExpression_With_left) => void,
   +'BinaryExpression[right]'?: (node: BinaryExpression_With_right) => void,
@@ -1980,6 +1992,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'PropertyDefinition[typeAnnotation]'?: (
     node: PropertyDefinition_With_typeAnnotation,
   ) => void,
+  +'PropertyDefinition[tsModifiers]'?: (
+    node: PropertyDefinition_With_tsModifiers,
+  ) => void,
   +QualifiedTypeIdentifier?: (node: QualifiedTypeIdentifier) => void,
   +'QualifiedTypeIdentifier[qualification]'?: (
     node: QualifiedTypeIdentifier_With_qualification,
@@ -2185,6 +2200,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'BigIntLiteralTypeAnnotation[raw]:exit'?: (
     node: BigIntLiteralTypeAnnotation_With_raw,
   ) => void,
+  +'BigIntTypeAnnotation:exit'?: (node: BigIntTypeAnnotation) => void,
   +'BinaryExpression:exit'?: (node: BinaryExpression) => void,
   +'BinaryExpression[left]:exit'?: (node: BinaryExpression_With_left) => void,
   +'BinaryExpression[right]:exit'?: (node: BinaryExpression_With_right) => void,
@@ -2884,6 +2900,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'PropertyDefinition[typeAnnotation]:exit'?: (
     node: PropertyDefinition_With_typeAnnotation,
   ) => void,
+  +'PropertyDefinition[tsModifiers]:exit'?: (
+    node: PropertyDefinition_With_tsModifiers,
+  ) => void,
   +'QualifiedTypeIdentifier:exit'?: (node: QualifiedTypeIdentifier) => void,
   +'QualifiedTypeIdentifier[qualification]:exit'?: (
     node: QualifiedTypeIdentifier_With_qualification,

package/dist/generated/predicates.js

@@ -6,6 +6,13 @@
  *
  * 
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 // lint directives to let us do some basic validation of generated files
 
@@ -30,6 +37,7 @@ exports.isAsyncKeyword = isAsyncKeyword;
 exports.isAwaitExpression = isAwaitExpression;
 exports.isAwaitKeyword = isAwaitKeyword;
 exports.isBigIntLiteralTypeAnnotation = isBigIntLiteralTypeAnnotation;
+exports.isBigIntTypeAnnotation = isBigIntTypeAnnotation;
 exports.isBinaryExpression = isBinaryExpression;
 exports.isBitwiseANDEqualToken = isBitwiseANDEqualToken;
 exports.isBitwiseANDToken = isBitwiseANDToken;
@@ -313,6 +321,10 @@ function isBigIntLiteralTypeAnnotation(node) {
   return node.type === 'BigIntLiteralTypeAnnotation';
 }
 
+function isBigIntTypeAnnotation(node) {
+  return node.type === 'BigIntTypeAnnotation';
+}
+
 function isBinaryExpression(node) {
   return node.type === 'BinaryExpression';
 }
@@ -1218,47 +1230,47 @@ function isYieldToken(node) {
 }
 
 function isAsKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'as';
+  return node.type === 'Identifier' && node.name === 'as' || node.type === 'Keyword' && node.value === 'as';
 }
 
 function isAsyncKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'async';
+  return node.type === 'Identifier' && node.name === 'async' || node.type === 'Keyword' && node.value === 'async';
 }
 
 function isAwaitKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'await';
+  return node.type === 'Identifier' && node.name === 'await' || node.type === 'Keyword' && node.value === 'await';
 }
 
 function isDeclareKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'declare';
+  return node.type === 'Identifier' && node.name === 'declare' || node.type === 'Keyword' && node.value === 'declare';
 }
 
 function isFromKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'from';
+  return node.type === 'Identifier' && node.name === 'from' || node.type === 'Keyword' && node.value === 'from';
 }
 
 function isGetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'get';
+  return node.type === 'Identifier' && node.name === 'get' || node.type === 'Keyword' && node.value === 'get';
 }
 
 function isLetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'let';
+  return node.type === 'Identifier' && node.name === 'let' || node.type === 'Keyword' && node.value === 'let';
 }
 
 function isModuleKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'module';
+  return node.type === 'Identifier' && node.name === 'module' || node.type === 'Keyword' && node.value === 'module';
 }
 
 function isOfKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'of';
+  return node.type === 'Identifier' && node.name === 'of' || node.type === 'Keyword' && node.value === 'of';
 }
 
 function isSetKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'set';
+  return node.type === 'Identifier' && node.name === 'set' || node.type === 'Keyword' && node.value === 'set';
 }
 
 function isTypeKeyword(node) {
-  return (node.type === 'Identifier' || node.type === 'Keyword') && node.value === 'type';
+  return node.type === 'Identifier' && node.name === 'type' || node.type === 'Keyword' && node.value === 'type';
 }
 
 function isCommaToken(node) {

package/dist/generated/predicates.js.flow

@@ -6,6 +6,13 @@
  *
  * @flow strict-local
  * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `yarn build`.
  */
 
 // lint directives to let us do some basic validation of generated files
@@ -56,6 +63,10 @@ export function isBigIntLiteralTypeAnnotation(
   return node.type === 'BigIntLiteralTypeAnnotation';
 }
 
+export function isBigIntTypeAnnotation(node: ESNode | Token): boolean %checks {
+  return node.type === 'BigIntTypeAnnotation';
+}
+
 export function isBinaryExpression(node: ESNode | Token): boolean %checks {
   return node.type === 'BinaryExpression';
 }
@@ -1024,78 +1035,78 @@ export function isYieldToken(node: ESNode | Token): boolean %checks {
 
 export function isAsKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'as'
+    (node.type === 'Identifier' && node.name === 'as') ||
+    (node.type === 'Keyword' && node.value === 'as')
   );
 }
 
 export function isAsyncKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'async'
+    (node.type === 'Identifier' && node.name === 'async') ||
+    (node.type === 'Keyword' && node.value === 'async')
   );
 }
 
 export function isAwaitKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'await'
+    (node.type === 'Identifier' && node.name === 'await') ||
+    (node.type === 'Keyword' && node.value === 'await')
   );
 }
 
 export function isDeclareKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'declare'
+    (node.type === 'Identifier' && node.name === 'declare') ||
+    (node.type === 'Keyword' && node.value === 'declare')
   );
 }
 
 export function isFromKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'from'
+    (node.type === 'Identifier' && node.name === 'from') ||
+    (node.type === 'Keyword' && node.value === 'from')
   );
 }
 
 export function isGetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'get'
+    (node.type === 'Identifier' && node.name === 'get') ||
+    (node.type === 'Keyword' && node.value === 'get')
   );
 }
 
 export function isLetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'let'
+    (node.type === 'Identifier' && node.name === 'let') ||
+    (node.type === 'Keyword' && node.value === 'let')
   );
 }
 
 export function isModuleKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'module'
+    (node.type === 'Identifier' && node.name === 'module') ||
+    (node.type === 'Keyword' && node.value === 'module')
   );
 }
 
 export function isOfKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'of'
+    (node.type === 'Identifier' && node.name === 'of') ||
+    (node.type === 'Keyword' && node.value === 'of')
   );
 }
 
 export function isSetKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'set'
+    (node.type === 'Identifier' && node.name === 'set') ||
+    (node.type === 'Keyword' && node.value === 'set')
   );
 }
 
 export function isTypeKeyword(node: ESNode | Token): boolean %checks {
   return (
-    (node.type === 'Identifier' || node.type === 'Keyword') &&
-    node.value === 'type'
+    (node.type === 'Identifier' && node.name === 'type') ||
+    (node.type === 'Keyword' && node.value === 'type')
   );
 }
 

package/dist/predicates.js

@@ -29,7 +29,9 @@ var _exportNames = {
   isNullLiteral: true,
   isNumericLiteral: true,
   isRegExpLiteral: true,
-  isStringLiteral: true
+  isStringLiteral: true,
+  isExpression: true,
+  isStatement: true
 };
 exports.isBigIntLiteral = isBigIntLiteral;
 exports.isBooleanLiteral = isBooleanLiteral;
@@ -37,6 +39,7 @@ exports.isClass = isClass;
 exports.isClassMember = isClassMember;
 exports.isClassMemberWithNonComputedName = isClassMemberWithNonComputedName;
 exports.isComment = isComment;
+exports.isExpression = isExpression;
 exports.isFunction = isFunction;
 exports.isMemberExpressionWithNonComputedProperty = isMemberExpressionWithNonComputedProperty;
 exports.isMethodDefinitionWithNonComputedName = isMethodDefinitionWithNonComputedName;
@@ -47,6 +50,7 @@ exports.isObjectPropertyWithShorthand = isObjectPropertyWithShorthand;
 exports.isOptionalMemberExpressionWithNonComputedProperty = isOptionalMemberExpressionWithNonComputedProperty;
 exports.isPropertyDefinitionWithNonComputedName = isPropertyDefinitionWithNonComputedName;
 exports.isRegExpLiteral = isRegExpLiteral;
+exports.isStatement = isStatement;
 exports.isStringLiteral = isStringLiteral;
 
 var _predicates = require("./generated/predicates");
@@ -124,4 +128,12 @@ function isRegExpLiteral(node) {
 
 function isStringLiteral(node) {
   return (0, _predicates.isLiteral)(node) && node.literalType === 'string';
+}
+
+function isExpression(node) {
+  return (0, _predicates.isThisExpression)(node) || (0, _predicates.isArrayExpression)(node) || (0, _predicates.isObjectExpression)(node) || (0, _predicates.isFunctionExpression)(node) || (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isYieldExpression)(node) || (0, _predicates.isLiteral)(node) || (0, _predicates.isUnaryExpression)(node) || (0, _predicates.isUpdateExpression)(node) || (0, _predicates.isBinaryExpression)(node) || (0, _predicates.isAssignmentExpression)(node) || (0, _predicates.isLogicalExpression)(node) || (0, _predicates.isMemberExpression)(node) || (0, _predicates.isConditionalExpression)(node) || (0, _predicates.isCallExpression)(node) || (0, _predicates.isNewExpression)(node) || (0, _predicates.isSequenceExpression)(node) || (0, _predicates.isTemplateLiteral)(node) || (0, _predicates.isTaggedTemplateExpression)(node) || (0, _predicates.isClassExpression)(node) || (0, _predicates.isMetaProperty)(node) || (0, _predicates.isIdentifier)(node) || (0, _predicates.isAwaitExpression)(node) || (0, _predicates.isImportExpression)(node) || (0, _predicates.isChainExpression)(node) || (0, _predicates.isTypeCastExpression)(node) || (0, _predicates.isJSXFragment)(node) || (0, _predicates.isJSXElement)(node);
+}
+
+function isStatement(node) {
+  return (0, _predicates.isBlockStatement)(node) || (0, _predicates.isBreakStatement)(node) || (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isContinueStatement)(node) || (0, _predicates.isDebuggerStatement)(node) || (0, _predicates.isDeclareClass)(node) || (0, _predicates.isDeclareVariable)(node) || (0, _predicates.isDeclareFunction)(node) || (0, _predicates.isDeclareInterface)(node) || (0, _predicates.isDeclareModule)(node) || (0, _predicates.isDeclareOpaqueType)(node) || (0, _predicates.isDeclareTypeAlias)(node) || (0, _predicates.isDoWhileStatement)(node) || (0, _predicates.isEmptyStatement)(node) || (0, _predicates.isEnumDeclaration)(node) || (0, _predicates.isExpressionStatement)(node) || (0, _predicates.isForInStatement)(node) || (0, _predicates.isForOfStatement)(node) || (0, _predicates.isForStatement)(node) || (0, _predicates.isFunctionDeclaration)(node) || (0, _predicates.isIfStatement)(node) || (0, _predicates.isInterfaceDeclaration)(node) || (0, _predicates.isLabeledStatement)(node) || (0, _predicates.isOpaqueType)(node) || (0, _predicates.isReturnStatement)(node) || (0, _predicates.isSwitchStatement)(node) || (0, _predicates.isThrowStatement)(node) || (0, _predicates.isTryStatement)(node) || (0, _predicates.isTypeAlias)(node) || (0, _predicates.isVariableDeclaration)(node) || (0, _predicates.isWhileStatement)(node) || (0, _predicates.isWithStatement)(node);
 }

package/dist/predicates.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 
@@ -13,18 +13,71 @@
 import type {ESNode, Token} from './types';
 
 import {
+  isArrayExpression,
   isArrowFunctionExpression,
+  isAssignmentExpression,
+  isAwaitExpression,
+  isBinaryExpression,
   isBlockComment,
+  isBlockStatement,
+  isBreakStatement,
+  isCallExpression,
+  isChainExpression,
   isClassDeclaration,
   isClassExpression,
+  isConditionalExpression,
+  isContinueStatement,
+  isDebuggerStatement,
+  isDeclareClass,
+  isDeclareFunction,
+  isDeclareInterface,
+  isDeclareModule,
+  isDeclareOpaqueType,
+  isDeclareTypeAlias,
+  isDeclareVariable,
+  isDoWhileStatement,
+  isEmptyStatement,
+  isEnumDeclaration,
+  isExpressionStatement,
+  isForInStatement,
+  isForOfStatement,
+  isForStatement,
   isFunctionDeclaration,
   isFunctionExpression,
+  isIdentifier,
+  isIfStatement,
+  isImportExpression,
+  isInterfaceDeclaration,
+  isJSXElement,
+  isJSXFragment,
+  isLabeledStatement,
   isLineComment,
   isLiteral,
+  isLogicalExpression,
   isMemberExpression,
+  isMetaProperty,
   isMethodDefinition,
-  isPropertyDefinition,
+  isNewExpression,
+  isObjectExpression,
+  isOpaqueType,
   isProperty,
+  isPropertyDefinition,
+  isReturnStatement,
+  isSequenceExpression,
+  isSwitchStatement,
+  isTaggedTemplateExpression,
+  isTemplateLiteral,
+  isThisExpression,
+  isThrowStatement,
+  isTryStatement,
+  isTypeAlias,
+  isTypeCastExpression,
+  isUnaryExpression,
+  isUpdateExpression,
+  isVariableDeclaration,
+  isWhileStatement,
+  isWithStatement,
+  isYieldExpression,
 } from './generated/predicates';
 
 export * from './generated/predicates';
@@ -112,3 +165,73 @@ export function isRegExpLiteral(node: ESNode): boolean %checks {
 export function isStringLiteral(node: ESNode): boolean %checks {
   return isLiteral(node) && node.literalType === 'string';
 }
+
+export function isExpression(node: ESNode): boolean %checks {
+  return (
+    isThisExpression(node) ||
+    isArrayExpression(node) ||
+    isObjectExpression(node) ||
+    isFunctionExpression(node) ||
+    isArrowFunctionExpression(node) ||
+    isYieldExpression(node) ||
+    isLiteral(node) ||
+    isUnaryExpression(node) ||
+    isUpdateExpression(node) ||
+    isBinaryExpression(node) ||
+    isAssignmentExpression(node) ||
+    isLogicalExpression(node) ||
+    isMemberExpression(node) ||
+    isConditionalExpression(node) ||
+    isCallExpression(node) ||
+    isNewExpression(node) ||
+    isSequenceExpression(node) ||
+    isTemplateLiteral(node) ||
+    isTaggedTemplateExpression(node) ||
+    isClassExpression(node) ||
+    isMetaProperty(node) ||
+    isIdentifier(node) ||
+    isAwaitExpression(node) ||
+    isImportExpression(node) ||
+    isChainExpression(node) ||
+    isTypeCastExpression(node) ||
+    isJSXFragment(node) ||
+    isJSXElement(node)
+  );
+}
+
+export function isStatement(node: ESNode): boolean %checks {
+  return (
+    isBlockStatement(node) ||
+    isBreakStatement(node) ||
+    isClassDeclaration(node) ||
+    isContinueStatement(node) ||
+    isDebuggerStatement(node) ||
+    isDeclareClass(node) ||
+    isDeclareVariable(node) ||
+    isDeclareFunction(node) ||
+    isDeclareInterface(node) ||
+    isDeclareModule(node) ||
+    isDeclareOpaqueType(node) ||
+    isDeclareTypeAlias(node) ||
+    isDoWhileStatement(node) ||
+    isEmptyStatement(node) ||
+    isEnumDeclaration(node) ||
+    isExpressionStatement(node) ||
+    isForInStatement(node) ||
+    isForOfStatement(node) ||
+    isForStatement(node) ||
+    isFunctionDeclaration(node) ||
+    isIfStatement(node) ||
+    isInterfaceDeclaration(node) ||
+    isLabeledStatement(node) ||
+    isOpaqueType(node) ||
+    isReturnStatement(node) ||
+    isSwitchStatement(node) ||
+    isThrowStatement(node) ||
+    isTryStatement(node) ||
+    isTypeAlias(node) ||
+    isVariableDeclaration(node) ||
+    isWhileStatement(node) ||
+    isWithStatement(node)
+  );
+}

package/dist/types.js.flow

@@ -38,7 +38,10 @@
 
 export type Range = [number, number];
 
-export interface BaseToken {
+export interface ObjectWithLoc {
+  +loc: SourceLocation;
+}
+export interface BaseToken extends ObjectWithLoc {
   +loc: SourceLocation;
   +range: Range;
 }
@@ -106,7 +109,7 @@ export interface Position {
 }
 
 // note: this is only ever present on Program.interpreter, never in the body
-interface InterpreterDirective extends BaseNode {
+export interface InterpreterDirective extends BaseNode {
   type: 'InterpreterDirective';
   value: string;
 }
@@ -226,6 +229,9 @@ export type Statement =
   | ClassDeclaration
   | ContinueStatement
   | DebuggerStatement
+  | DeclareClass
+  | DeclareVariable
+  | DeclareFunction
   | DeclareInterface
   | DeclareModule
   | DeclareOpaqueType
@@ -471,7 +477,7 @@ export interface ObjectPropertyWithShorthandStaticName
   // shorthand values *must* be identifiers (that look the same as the key)
   +value: Identifier;
   +kind: 'init';
-  +method: boolean;
+  +method: false;
   +shorthand: true;
 }
 export interface ObjectPropertyWithComputedName extends ObjectPropertyBase {
@@ -850,7 +856,7 @@ interface BaseClass extends BaseNode {
   +body: ClassBody;
 
   +typeParameters: null | TypeParameterDeclaration;
-  +superTypeParameters: null | TypeParameterDeclaration;
+  +superTypeParameters: null | TypeParameterInstantiation;
   +implements: $ReadOnlyArray<ClassImplements>;
   +decorators: $ReadOnlyArray<Decorator>;
 }
@@ -1024,13 +1030,30 @@ export type NamedDeclaration =
   | InterfaceDeclaration
   | EnumDeclaration;
 
-export interface ExportNamedDeclaration extends BaseNode {
+interface ExportNamedDeclarationBase extends BaseNode {
   +type: 'ExportNamedDeclaration';
   +declaration?: NamedDeclaration | null;
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
-  +source?: Literal | null;
+  +source?: StringLiteral | null;
   +exportKind: 'value' | 'type';
 }
+export interface ExportNamedDeclarationWithSpecifiers
+  extends ExportNamedDeclarationBase {
+  +type: 'ExportNamedDeclaration';
+  +declaration: null;
+  +source: null;
+  +specifiers: $ReadOnlyArray<ExportSpecifier>;
+}
+export interface ExportNamedDeclarationWithDeclaration
+  extends ExportNamedDeclarationBase {
+  +type: 'ExportNamedDeclaration';
+  +declaration: NamedDeclaration;
+  +source: null;
+  +specifiers: [];
+}
+export type ExportNamedDeclaration =
+  | ExportNamedDeclarationWithSpecifiers
+  | ExportNamedDeclarationWithDeclaration;
 
 export interface ExportSpecifier extends BaseNode {
   +type: 'ExportSpecifier';
@@ -1045,7 +1068,7 @@ export interface ExportDefaultDeclaration extends BaseNode {
 
 export interface ExportAllDeclaration extends BaseNode {
   +type: 'ExportAllDeclaration';
-  +source: Literal;
+  +source: StringLiteral;
   +exportKind: 'value' | 'type';
   +exported?: Identifier | null;
 }
@@ -1062,6 +1085,7 @@ export interface AwaitExpression extends BaseNode {
 export type TypeAnnotationType =
   | NumberTypeAnnotation
   | StringTypeAnnotation
+  | BigIntTypeAnnotation
   | BooleanTypeAnnotation
   | NullLiteralTypeAnnotation
   | AnyTypeAnnotation
@@ -1125,6 +1149,9 @@ export interface NumberTypeAnnotation extends BaseNode {
 export interface StringTypeAnnotation extends BaseNode {
   +type: 'StringTypeAnnotation';
 }
+export interface BigIntTypeAnnotation extends BaseNode {
+  +type: 'BigIntTypeAnnotation';
+}
 export interface BooleanTypeAnnotation extends BaseNode {
   +type: 'BooleanTypeAnnotation';
 }
@@ -1161,13 +1188,14 @@ export interface NumberLiteralTypeAnnotation extends BaseNode {
 }
 export interface BigIntLiteralTypeAnnotation extends BaseNode {
   +type: 'BigIntLiteralTypeAnnotation';
-  +value: null;
+  +bigint: string;
+  +value: null /* | bigint */;
   +raw: string;
 }
 export interface BooleanLiteralTypeAnnotation extends BaseNode {
   +type: 'BooleanLiteralTypeAnnotation';
   +value: boolean;
-  +raw: string;
+  +raw: 'true' | 'false';
 }
 export interface ArrayTypeAnnotation extends BaseNode {
   +type: 'ArrayTypeAnnotation';
@@ -1196,7 +1224,7 @@ export interface TypeofTypeAnnotation extends BaseNode {
 }
 export interface TupleTypeAnnotation extends BaseNode {
   +type: 'TupleTypeAnnotation';
-  +types: TypeAnnotationType;
+  +types: $ReadOnlyArray<TypeAnnotationType>;
 }
 
 // type T = { [[foo]]: number };
@@ -1230,7 +1258,7 @@ export interface FunctionTypeAnnotation extends BaseNode {
   +returnType: TypeAnnotationType;
   +rest: null | FunctionTypeParam;
   +typeParameters: null | TypeParameterDeclaration;
-  +this: TypeAnnotationType | null;
+  +this: FunctionTypeParam | null;
 }
 export interface FunctionTypeParam extends BaseNode {
   +type: 'FunctionTypeParam';
@@ -1255,23 +1283,58 @@ export interface ObjectTypeAnnotation extends BaseNode {
   +callProperties: $ReadOnlyArray<ObjectTypeCallProperty>;
   +internalSlots: $ReadOnlyArray<ObjectTypeInternalSlot>;
 }
-export interface ObjectTypeProperty extends BaseNode {
+interface ObjectTypePropertyBase extends BaseNode {
   +type: 'ObjectTypeProperty';
-  +key: Identifier;
+  +key: Identifier | StringLiteral;
   +value: TypeAnnotationType;
   +method: boolean;
   +optional: boolean;
-  +static: false; // can't be static
-  +proto: false; // ???
+  +static: boolean; // only applies to the "declare class" case
+  +proto: boolean; // only applies to the "declare class" case
+  +variance: Variance | null;
+  +kind: 'init' | 'get' | 'set';
+
+  +parent: ObjectTypeAnnotation;
+}
+export interface ObjectTypeMethodSignature extends ObjectTypePropertyBase {
+  +type: 'ObjectTypeProperty';
+  +value: FunctionTypeAnnotation;
+  +method: true;
+  +optional: false;
+  +variance: null;
+  +kind: 'init';
+
+  +parent: ObjectTypeAnnotation;
+}
+export interface ObjectTypePropertySignature extends ObjectTypePropertyBase {
+  +type: 'ObjectTypeProperty';
+  +value: TypeAnnotationType;
+  +method: false;
+  +optional: boolean;
   +variance: Variance | null;
   +kind: 'init';
 
   +parent: ObjectTypeAnnotation;
 }
+export interface ObjectTypeAccessorSignature extends ObjectTypePropertyBase {
+  +type: 'ObjectTypeProperty';
+  +value: FunctionTypeAnnotation;
+  +method: false;
+  +optional: false;
+  +variance: null;
+  +kind: 'get' | 'set';
+
+  +parent: ObjectTypeAnnotation;
+}
+export type ObjectTypeProperty =
+  | ObjectTypeMethodSignature
+  | ObjectTypePropertySignature
+  | ObjectTypeAccessorSignature;
+
 export interface ObjectTypeCallProperty extends BaseNode {
   +type: 'ObjectTypeCallProperty';
   +value: FunctionTypeAnnotation;
-  +static: false; // can't be static
+  +static: boolean; // can only be static when defined on a declare class
 
   +parent: ObjectTypeAnnotation;
 }
@@ -1280,7 +1343,7 @@ export interface ObjectTypeIndexer extends BaseNode {
   +id: null | Identifier;
   +key: TypeAnnotationType;
   +value: TypeAnnotationType;
-  +static: false; // can't be static
+  +static: boolean; // can only be static when defined on a declare class
   +variance: null | Variance;
 
   +parent: ObjectTypeAnnotation;
@@ -1294,13 +1357,13 @@ export interface ObjectTypeSpreadProperty extends BaseNode {
 
 export interface IndexedAccessType extends BaseNode {
   +type: 'IndexedAccessType';
-  +objectType: TypeAnnotation;
-  +indexType: TypeAnnotation;
+  +objectType: TypeAnnotationType;
+  +indexType: TypeAnnotationType;
 }
 export interface OptionalIndexedAccessType extends BaseNode {
   +type: 'OptionalIndexedAccessType';
-  +objectType: TypeAnnotation;
-  +indexType: TypeAnnotation;
+  +objectType: TypeAnnotationType;
+  +indexType: TypeAnnotationType;
   +optional: boolean;
 }
 
@@ -1326,7 +1389,7 @@ export interface InterfaceDeclaration extends BaseInterfaceDeclaration {
 export interface InterfaceExtends extends BaseNode {
   +type: 'InterfaceExtends';
   +id: Identifier;
-  +typeParameters: null | TypeParameterDeclaration;
+  +typeParameters: null | TypeParameterInstantiation;
 
   +parent: InterfaceDeclaration | DeclareInterface;
 }
@@ -1334,7 +1397,7 @@ export interface InterfaceExtends extends BaseNode {
 export interface ClassImplements extends BaseNode {
   +type: 'ClassImplements';
   +id: Identifier;
-  +typeParameters: null | TypeParameterDeclaration;
+  +typeParameters: null | TypeParameterInstantiation;
 
   +parent: AClass | DeclareClass;
 }
@@ -1476,7 +1539,12 @@ export interface DeclareVariable extends BaseNode {
 
 export interface DeclareFunction extends BaseNode {
   +type: 'DeclareFunction';
-  +id: Identifier;
+  // the function signature is stored as a type annotation on the ID
+  +id: interface extends Identifier {
+    +typeAnnotation: interface extends TypeAnnotation {
+      +typeAnnotation: FunctionTypeAnnotation,
+    },
+  };
   +predicate: InferredPredicate | DeclaredPredicate | null;
 }
 
@@ -1505,19 +1573,49 @@ export interface DeclareExportAllDeclaration extends BaseNode {
   +source: StringLiteral;
 }
 
-export interface DeclareExportDeclaration extends BaseNode {
+interface DeclareExportDeclarationBase extends BaseNode {
   +type: 'DeclareExportDeclaration';
   +specifiers: $ReadOnlyArray<ExportSpecifier>;
+  +source: StringLiteral | null;
+  +default: boolean;
+}
+export interface DeclareExportDefaultDeclaration
+  extends DeclareExportDeclarationBase {
+  +type: 'DeclareExportDeclaration';
+  +declaration: DeclareClass | DeclareFunction | TypeAnnotationType;
+  +default: true;
+  // default cannot have a source
+  +source: null;
+  // default cannot have specifiers
+  +specifiers: [];
+}
+export interface DeclareExportDeclarationNamedWithDeclaration
+  extends DeclareExportDeclarationBase {
+  +type: 'DeclareExportDeclaration';
   +declaration:
-    | TypeAlias
     | DeclareClass
     | DeclareFunction
-    | DeclareOpaqueType
     | DeclareInterface
-    | null;
-  +source: StringLiteral | null;
-  +default: boolean;
+    | DeclareOpaqueType
+    | DeclareVariable;
+  +default: false;
+  +source: null;
+  // default cannot have specifiers and a declaration
+  +specifiers: [];
+}
+export interface DeclareExportDeclarationNamedWithSpecifiers
+  extends DeclareExportDeclarationBase {
+  +type: 'DeclareExportDeclaration';
+  // with a source you can't have a declaration
+  +declaration: null;
+  +default: false;
+  +source: StringLiteral;
+  +specifiers: $ReadOnlyArray<ExportSpecifier>;
 }
+export type DeclareExportDeclaration =
+  | DeclareExportDefaultDeclaration
+  | DeclareExportDeclarationNamedWithDeclaration
+  | DeclareExportDeclarationNamedWithSpecifiers;
 
 export interface DeclareModuleExports extends BaseNode {
   +type: 'DeclareModuleExports';

package/package.json

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