hermes-estree 0.20.0 → 0.21.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -17,7 +17,7 @@
 
 // lint directives to let us do some basic validation of generated files
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
-/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray, $FlowFixMe */
 
 'use strict';
 
@@ -28,6 +28,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsConstExpression,
   AsExpression,
   AssignmentExpression,
   AssignmentPattern,
@@ -72,6 +73,8 @@ import type {
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
+  EnumBigIntBody,
+  EnumBigIntMember,
   EnumBooleanBody,
   EnumBooleanMember,
   EnumDeclaration,
@@ -241,6 +244,9 @@ interface ArrowFunctionExpression_With_expression
 interface ArrowFunctionExpression_With_async extends ArrowFunctionExpression {
   +async: $NonMaybeType<ArrowFunctionExpression['async']>;
 }
+interface AsConstExpression_With_expression extends AsConstExpression {
+  +expression: $NonMaybeType<AsConstExpression['expression']>;
+}
 interface AsExpression_With_expression extends AsExpression {
   +expression: $NonMaybeType<AsExpression['expression']>;
 }
@@ -570,6 +576,21 @@ interface DoWhileStatement_With_body extends DoWhileStatement {
 interface DoWhileStatement_With_test extends DoWhileStatement {
   +test: $NonMaybeType<DoWhileStatement['test']>;
 }
+interface EnumBigIntBody_With_members extends EnumBigIntBody {
+  +members: $NonMaybeType<EnumBigIntBody['members']>;
+}
+interface EnumBigIntBody_With_explicitType extends EnumBigIntBody {
+  +explicitType: $NonMaybeType<EnumBigIntBody['explicitType']>;
+}
+interface EnumBigIntBody_With_hasUnknownMembers extends EnumBigIntBody {
+  +hasUnknownMembers: $NonMaybeType<EnumBigIntBody['hasUnknownMembers']>;
+}
+interface EnumBigIntMember_With_id extends EnumBigIntMember {
+  +id: $NonMaybeType<EnumBigIntMember['id']>;
+}
+interface EnumBigIntMember_With_init extends EnumBigIntMember {
+  +init: $NonMaybeType<EnumBigIntMember['init']>;
+}
 interface EnumBooleanBody_With_members extends EnumBooleanBody {
   +members: $NonMaybeType<EnumBooleanBody['members']>;
 }
@@ -1314,6 +1335,9 @@ interface TryStatement_With_finalizer extends TryStatement {
 interface TupleTypeAnnotation_With_types extends TupleTypeAnnotation {
   +types: $NonMaybeType<TupleTypeAnnotation['types']>;
 }
+interface TupleTypeAnnotation_With_inexact extends TupleTypeAnnotation {
+  +inexact: $NonMaybeType<TupleTypeAnnotation['inexact']>;
+}
 interface TupleTypeLabeledElement_With_label extends TupleTypeLabeledElement {
   +label: $NonMaybeType<TupleTypeLabeledElement['label']>;
 }
@@ -1395,8 +1419,8 @@ interface TypePredicate_With_parameterName extends TypePredicate {
 interface TypePredicate_With_typeAnnotation extends TypePredicate {
   +typeAnnotation: $NonMaybeType<TypePredicate['typeAnnotation']>;
 }
-interface TypePredicate_With_asserts extends TypePredicate {
-  +asserts: $NonMaybeType<TypePredicate['asserts']>;
+interface TypePredicate_With_kind extends TypePredicate {
+  +kind: $NonMaybeType<TypePredicate['kind']>;
 }
 interface UnaryExpression_With_operator extends UnaryExpression {
   +operator: $NonMaybeType<UnaryExpression['operator']>;
@@ -1493,6 +1517,7 @@ type ExpressionSpecialSelector =
   | MetaProperty
   | ArrayExpression
   | ArrowFunctionExpression
+  | AsConstExpression
   | AsExpression
   | AssignmentExpression
   | AwaitExpression
@@ -1563,6 +1588,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ArrowFunctionExpression[async]'?: (
     node: ArrowFunctionExpression_With_async,
   ) => void,
+  +AsConstExpression?: (node: AsConstExpression) => void,
+  +'AsConstExpression[expression]'?: (
+    node: AsConstExpression_With_expression,
+  ) => void,
   +AsExpression?: (node: AsExpression) => void,
   +'AsExpression[expression]'?: (node: AsExpression_With_expression) => void,
   +'AsExpression[typeAnnotation]'?: (
@@ -1821,6 +1850,17 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DoWhileStatement[test]'?: (node: DoWhileStatement_With_test) => void,
   +EmptyStatement?: (node: EmptyStatement) => void,
   +EmptyTypeAnnotation?: (node: EmptyTypeAnnotation) => void,
+  +EnumBigIntBody?: (node: EnumBigIntBody) => void,
+  +'EnumBigIntBody[members]'?: (node: EnumBigIntBody_With_members) => void,
+  +'EnumBigIntBody[explicitType]'?: (
+    node: EnumBigIntBody_With_explicitType,
+  ) => void,
+  +'EnumBigIntBody[hasUnknownMembers]'?: (
+    node: EnumBigIntBody_With_hasUnknownMembers,
+  ) => void,
+  +EnumBigIntMember?: (node: EnumBigIntMember) => void,
+  +'EnumBigIntMember[id]'?: (node: EnumBigIntMember_With_id) => void,
+  +'EnumBigIntMember[init]'?: (node: EnumBigIntMember_With_init) => void,
   +EnumBooleanBody?: (node: EnumBooleanBody) => void,
   +'EnumBooleanBody[members]'?: (node: EnumBooleanBody_With_members) => void,
   +'EnumBooleanBody[explicitType]'?: (
@@ -2422,6 +2462,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TupleTypeAnnotation[types]'?: (
     node: TupleTypeAnnotation_With_types,
   ) => void,
+  +'TupleTypeAnnotation[inexact]'?: (
+    node: TupleTypeAnnotation_With_inexact,
+  ) => void,
   +TupleTypeLabeledElement?: (node: TupleTypeLabeledElement) => void,
   +'TupleTypeLabeledElement[label]'?: (
     node: TupleTypeLabeledElement_With_label,
@@ -2492,7 +2535,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypePredicate[typeAnnotation]'?: (
     node: TypePredicate_With_typeAnnotation,
   ) => void,
-  +'TypePredicate[asserts]'?: (node: TypePredicate_With_asserts) => void,
+  +'TypePredicate[kind]'?: (node: TypePredicate_With_kind) => void,
   +UnaryExpression?: (node: UnaryExpression) => void,
   +'UnaryExpression[operator]'?: (node: UnaryExpression_With_operator) => void,
   +'UnaryExpression[argument]'?: (node: UnaryExpression_With_argument) => void,
@@ -2578,6 +2621,10 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'ArrowFunctionExpression[async]:exit'?: (
     node: ArrowFunctionExpression_With_async,
   ) => void,
+  +'AsConstExpression:exit'?: (node: AsConstExpression) => void,
+  +'AsConstExpression[expression]:exit'?: (
+    node: AsConstExpression_With_expression,
+  ) => void,
   +'AsExpression:exit'?: (node: AsExpression) => void,
   +'AsExpression[expression]:exit'?: (
     node: AsExpression_With_expression,
@@ -2866,6 +2913,17 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'DoWhileStatement[test]:exit'?: (node: DoWhileStatement_With_test) => void,
   +'EmptyStatement:exit'?: (node: EmptyStatement) => void,
   +'EmptyTypeAnnotation:exit'?: (node: EmptyTypeAnnotation) => void,
+  +'EnumBigIntBody:exit'?: (node: EnumBigIntBody) => void,
+  +'EnumBigIntBody[members]:exit'?: (node: EnumBigIntBody_With_members) => void,
+  +'EnumBigIntBody[explicitType]:exit'?: (
+    node: EnumBigIntBody_With_explicitType,
+  ) => void,
+  +'EnumBigIntBody[hasUnknownMembers]:exit'?: (
+    node: EnumBigIntBody_With_hasUnknownMembers,
+  ) => void,
+  +'EnumBigIntMember:exit'?: (node: EnumBigIntMember) => void,
+  +'EnumBigIntMember[id]:exit'?: (node: EnumBigIntMember_With_id) => void,
+  +'EnumBigIntMember[init]:exit'?: (node: EnumBigIntMember_With_init) => void,
   +'EnumBooleanBody:exit'?: (node: EnumBooleanBody) => void,
   +'EnumBooleanBody[members]:exit'?: (
     node: EnumBooleanBody_With_members,
@@ -3523,6 +3581,9 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TupleTypeAnnotation[types]:exit'?: (
     node: TupleTypeAnnotation_With_types,
   ) => void,
+  +'TupleTypeAnnotation[inexact]:exit'?: (
+    node: TupleTypeAnnotation_With_inexact,
+  ) => void,
   +'TupleTypeLabeledElement:exit'?: (node: TupleTypeLabeledElement) => void,
   +'TupleTypeLabeledElement[label]:exit'?: (
     node: TupleTypeLabeledElement_With_label,
@@ -3597,7 +3658,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'TypePredicate[typeAnnotation]:exit'?: (
     node: TypePredicate_With_typeAnnotation,
   ) => void,
-  +'TypePredicate[asserts]:exit'?: (node: TypePredicate_With_asserts) => void,
+  +'TypePredicate[kind]:exit'?: (node: TypePredicate_With_kind) => void,
   +'UnaryExpression:exit'?: (node: UnaryExpression) => void,
   +'UnaryExpression[operator]:exit'?: (
     node: UnaryExpression_With_operator,

package/dist/generated/predicates.js

@@ -17,12 +17,20 @@
 
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
 
-/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray, $FlowFixMe */
 'use strict';
 /*::
 import type {
   ESNode,
   Token,
+  AFunction,
+  ClassMember,
+  BigIntLiteral,
+  BooleanLiteral,
+  NullLiteral,
+  NumericLiteral,
+  RegExpLiteral,
+  StringLiteral,
   Identifier,
   JSXIdentifier,
   JSXText,
@@ -31,6 +39,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsConstExpression,
   AsExpression,
   AssignmentExpression,
   AssignmentPattern,
@@ -75,6 +84,8 @@ import type {
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
+  EnumBigIntBody,
+  EnumBigIntMember,
   EnumBooleanBody,
   EnumBooleanMember,
   EnumDeclaration,
@@ -198,7 +209,7 @@ import type {
   LineComment,
   BlockComment,
   MostTokens,
-} from 'hermes-estree';
+} from '../types';
 */
 
 Object.defineProperty(exports, "__esModule", {
@@ -209,6 +220,7 @@ exports.isArrayExpression = isArrayExpression;
 exports.isArrayPattern = isArrayPattern;
 exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
 exports.isArrowFunctionExpression = isArrowFunctionExpression;
+exports.isAsConstExpression = isAsConstExpression;
 exports.isAsExpression = isAsExpression;
 exports.isAsKeyword = isAsKeyword;
 exports.isAssignmentExpression = isAssignmentExpression;
@@ -291,6 +303,8 @@ exports.isDotToken = isDotToken;
 exports.isElseToken = isElseToken;
 exports.isEmptyStatement = isEmptyStatement;
 exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
+exports.isEnumBigIntBody = isEnumBigIntBody;
+exports.isEnumBigIntMember = isEnumBigIntMember;
 exports.isEnumBooleanBody = isEnumBooleanBody;
 exports.isEnumBooleanMember = isEnumBooleanMember;
 exports.isEnumDeclaration = isEnumDeclaration;
@@ -549,6 +563,14 @@ function isArrowFunctionExpression(node
   return node.type === 'ArrowFunctionExpression';
 }
 
+function isAsConstExpression(node
+/*: ESNode | Token */
+)
+/*: node is AsConstExpression */
+{
+  return node.type === 'AsConstExpression';
+}
+
 function isAsExpression(node
 /*: ESNode | Token */
 )
@@ -901,6 +923,22 @@ function isEmptyTypeAnnotation(node
   return node.type === 'EmptyTypeAnnotation';
 }
 
+function isEnumBigIntBody(node
+/*: ESNode | Token */
+)
+/*: node is EnumBigIntBody */
+{
+  return node.type === 'EnumBigIntBody';
+}
+
+function isEnumBigIntMember(node
+/*: ESNode | Token */
+)
+/*: node is EnumBigIntMember */
+{
+  return node.type === 'EnumBigIntMember';
+}
+
 function isEnumBooleanBody(node
 /*: ESNode | Token */
 )

package/dist/generated/predicates.js.flow

@@ -16,7 +16,7 @@
 
 // lint directives to let us do some basic validation of generated files
 /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */
-/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray */
+/* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray, $FlowFixMe */
 
 'use strict';
 
@@ -24,6 +24,14 @@
 import type {
   ESNode,
   Token,
+  AFunction,
+  ClassMember,
+  BigIntLiteral,
+  BooleanLiteral,
+  NullLiteral,
+  NumericLiteral,
+  RegExpLiteral,
+  StringLiteral,
   Identifier,
   JSXIdentifier,
   JSXText,
@@ -32,6 +40,7 @@ import type {
   ArrayPattern,
   ArrayTypeAnnotation,
   ArrowFunctionExpression,
+  AsConstExpression,
   AsExpression,
   AssignmentExpression,
   AssignmentPattern,
@@ -76,6 +85,8 @@ import type {
   DoWhileStatement,
   EmptyStatement,
   EmptyTypeAnnotation,
+  EnumBigIntBody,
+  EnumBigIntMember,
   EnumBooleanBody,
   EnumBooleanMember,
   EnumDeclaration,
@@ -199,7 +210,7 @@ import type {
   LineComment,
   BlockComment,
   MostTokens,
-} from 'hermes-estree';
+} from '../types';
 */
 
 
@@ -243,6 +254,11 @@ export function isArrowFunctionExpression(node /*: ESNode | Token */) /*: node i
 }
     
 
+export function isAsConstExpression(node /*: ESNode | Token */) /*: node is AsConstExpression */ {
+  return node.type === 'AsConstExpression';
+}
+    
+
 export function isAsExpression(node /*: ESNode | Token */) /*: node is AsExpression */ {
   return node.type === 'AsExpression';
 }
@@ -463,6 +479,16 @@ export function isEmptyTypeAnnotation(node /*: ESNode | Token */) /*: node is Em
 }
     
 
+export function isEnumBigIntBody(node /*: ESNode | Token */) /*: node is EnumBigIntBody */ {
+  return node.type === 'EnumBigIntBody';
+}
+    
+
+export function isEnumBigIntMember(node /*: ESNode | Token */) /*: node is EnumBigIntMember */ {
+  return node.type === 'EnumBigIntMember';
+}
+    
+
 export function isEnumBooleanBody(node /*: ESNode | Token */) /*: node is EnumBooleanBody */ {
   return node.type === 'EnumBooleanBody';
 }

package/dist/predicates.js

@@ -5,9 +5,43 @@
  * LICENSE file in the root directory of this source tree.
  *
  * 
- * @format
  */
 'use strict';
+/*::
+import type {
+  ESNode,
+  Token,
+  MostTokens,
+  BlockComment,
+  LineComment,
+  AFunction,
+  PropertyDefinition,
+  PropertyDefinitionWithNonComputedName,
+  MethodDefinition,
+  MethodDefinitionConstructor,
+  MethodDefinitionWithNonComputedName,
+  MemberExpression,
+  MemberExpressionWithNonComputedName,
+  ObjectPropertyWithShorthandStaticName,
+  ObjectPropertyWithNonShorthandStaticName,
+  DestructuringObjectPropertyWithShorthandStaticName,
+  DestructuringObjectPropertyWithNonShorthandStaticName,
+  ClassMember,
+  ClassDeclaration,
+  ClassExpression,
+  Literal,
+  BigIntLiteral,
+  BooleanLiteral,
+  NullLiteral,
+  NumericLiteral,
+  RegExpLiteral,
+  StringLiteral,
+  Identifier,
+  EnumDefaultedMember,
+  Expression,
+  Statement,
+} from './types';
+*/
 
 Object.defineProperty(exports, "__esModule", {
   value: true
@@ -62,97 +96,155 @@ Object.keys(_predicates).forEach(function (key) {
   exports[key] = _predicates[key];
 });
 
-// $FlowFixMe[deprecated-type]
-function isClass(node) {
-  return (0, _predicates.isClassDeclaration)(node) || (0, _predicates.isClassExpression)(node);
+function isClass(node
+/*: ESNode */
+)
+/*: node is (ClassDeclaration | ClassExpression) */
+{
+  return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
 }
 
-function isPropertyDefinitionWithNonComputedName(node // $FlowFixMe[deprecated-type]
-) {
-  return (0, _predicates.isPropertyDefinition)(node) && node.computed === false;
-} // $FlowFixMe[deprecated-type]
-
-
-function isClassMember(node) {
-  return (0, _predicates.isPropertyDefinition)(node) || (0, _predicates.isMethodDefinition)(node);
+function isPropertyDefinitionWithNonComputedName(node
+/*: ESNode */
+)
+/*: node is PropertyDefinitionWithNonComputedName */
+{
+  return node.type === 'PropertyDefinition' && node.computed === false;
 }
 
-function isClassMemberWithNonComputedName(node // $FlowFixMe[deprecated-type]
-) {
-  return isClassMember(node) && node.computed === false;
-} // $FlowFixMe[deprecated-type]
-
-
-function isComment(node) {
-  return (0, _predicates.isBlockComment)(node) || (0, _predicates.isLineComment)(node);
-} // $FlowFixMe[deprecated-type]
-
-
-function isFunction(node) {
-  return (0, _predicates.isArrowFunctionExpression)(node) || (0, _predicates.isFunctionDeclaration)(node) || (0, _predicates.isFunctionExpression)(node);
+function isClassMember(node
+/*: ESNode */
+)
+/*: node is ClassMember */
+{
+  return node.type === 'PropertyDefinition' || node.type === 'MethodDefinition';
 }
 
-function isMethodDefinitionWithNonComputedName(node // $FlowFixMe[deprecated-type]
-) {
-  return (0, _predicates.isMethodDefinition)(node) && node.computed === false;
+function isClassMemberWithNonComputedName(node
+/*: ESNode */
+)
+/*: node is (PropertyDefinitionWithNonComputedName | MethodDefinitionConstructor | MethodDefinitionWithNonComputedName) */
+{
+  return (node.type === 'PropertyDefinition' || node.type === 'MethodDefinition') && node.computed === false;
 }
 
-function isMemberExpressionWithNonComputedProperty(node // $FlowFixMe[deprecated-type]
-) {
-  return (0, _predicates.isMemberExpression)(node) && node.computed === false;
+function isComment(node
+/*: ESNode | Token */
+)
+/*: node is (MostTokens | BlockComment | LineComment) */
+{
+  return node.type === 'Block' || node.type === 'Line';
 }
 
-function isOptionalMemberExpressionWithNonComputedProperty(node // $FlowFixMe[deprecated-type]
-) {
-  return (0, _predicates.isMemberExpression)(node) && node.computed === false;
-} // $FlowFixMe[deprecated-type]
-
-
-function isObjectPropertyWithShorthand(node) {
-  return (0, _predicates.isProperty)(node) && node.shorthand === true;
+function isFunction(node
+/*: ESNode */
+)
+/*: node is AFunction */
+{
+  return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression';
 }
 
-function isObjectPropertyWithNonComputedName(node // $FlowFixMe[deprecated-type]
-) {
-  return (0, _predicates.isProperty)(node) && node.computed === false;
-} // $FlowFixMe[deprecated-type]
-
-
-function isBigIntLiteral(node) {
-  return (0, _predicates.isLiteral)(node) && node.literalType === 'bigint';
-} // $FlowFixMe[deprecated-type]
-
-
-function isBooleanLiteral(node) {
-  return (0, _predicates.isLiteral)(node) && node.literalType === 'boolean';
-} // $FlowFixMe[deprecated-type]
+function isMethodDefinitionWithNonComputedName(node
+/*: ESNode */
+)
+/*: node is (MethodDefinitionConstructor | MethodDefinitionWithNonComputedName) */
+{
+  return node.type === 'MethodDefinition' && node.computed === false;
+}
 
+function isMemberExpressionWithNonComputedProperty(node
+/*: ESNode */
+)
+/*: node is MemberExpressionWithNonComputedName */
+{
+  return node.type === 'MemberExpression' && node.computed === false;
+}
 
-function isNullLiteral(node) {
-  return (0, _predicates.isLiteral)(node) && node.literalType === 'null';
-} // $FlowFixMe[deprecated-type]
+function isOptionalMemberExpressionWithNonComputedProperty(node
+/*: ESNode */
+)
+/*: node is MemberExpressionWithNonComputedName */
+{
+  return node.type === 'MemberExpression' && node.computed === false;
+}
 
+function isObjectPropertyWithShorthand(node
+/*: ESNode */
+)
+/*: node is (ObjectPropertyWithShorthandStaticName | DestructuringObjectPropertyWithShorthandStaticName) */
+{
+  return node.type === 'Property' && node.shorthand === true;
+}
 
-function isNumericLiteral(node) {
-  return (0, _predicates.isLiteral)(node) && node.literalType === 'numeric';
-} // $FlowFixMe[deprecated-type]
+function isObjectPropertyWithNonComputedName(node
+/*: ESNode */
+)
+/*: node is (ObjectPropertyWithNonShorthandStaticName | ObjectPropertyWithShorthandStaticName | DestructuringObjectPropertyWithNonShorthandStaticName | DestructuringObjectPropertyWithShorthandStaticName) */
+{
+  return node.type === 'Property' && node.computed === false;
+}
 
+function isBigIntLiteral(node
+/*: ESNode */
+)
+/*: node is BigIntLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'bigint';
+}
 
-function isRegExpLiteral(node) {
-  return (0, _predicates.isLiteral)(node) && node.literalType === 'regexp';
-} // $FlowFixMe[deprecated-type]
+function isBooleanLiteral(node
+/*: ESNode */
+)
+/*: node is BooleanLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'boolean';
+}
 
+function isNullLiteral(node
+/*: ESNode */
+)
+/*: node is NullLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'null';
+}
 
-function isStringLiteral(node) {
-  return (0, _predicates.isLiteral)(node) && node.literalType === 'string';
-} // $FlowFixMe[deprecated-type]
+function isNumericLiteral(node
+/*: ESNode */
+)
+/*: node is NumericLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'numeric';
+}
 
+function isRegExpLiteral(node
+/*: ESNode */
+)
+/*: node is RegExpLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'regexp';
+}
 
-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.isAsExpression)(node) || (0, _predicates.isJSXFragment)(node) || (0, _predicates.isJSXElement)(node);
-} // $FlowFixMe[deprecated-type]
+function isStringLiteral(node
+/*: ESNode */
+)
+/*: node is StringLiteral */
+{
+  return node.type === 'Literal' && node.literalType === 'string';
+}
 
+function isExpression(node
+/*: ESNode */
+)
+/*: node is Expression */
+{
+  return node.type === 'ThisExpression' || node.type === 'ArrayExpression' || node.type === 'ObjectExpression' || // $FlowFixMe[incompatible-type]
+  node.type === 'ObjectExpression' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression' || node.type === 'YieldExpression' || node.type === 'Literal' || node.type === 'UnaryExpression' || node.type === 'UpdateExpression' || node.type === 'BinaryExpression' || node.type === 'AssignmentExpression' || node.type === 'LogicalExpression' || node.type === 'MemberExpression' || node.type === 'ConditionalExpression' || node.type === 'CallExpression' || node.type === 'NewExpression' || node.type === 'SequenceExpression' || node.type === 'TemplateLiteral' || node.type === 'TaggedTemplateExpression' || node.type === 'ClassExpression' || node.type === 'MetaProperty' || node.type === 'Identifier' || node.type === 'AwaitExpression' || node.type === 'ImportExpression' || node.type === 'ChainExpression' || node.type === 'TypeCastExpression' || node.type === 'AsExpression' || node.type === 'AsConstExpression' || node.type === 'JSXFragment' || node.type === 'JSXElement';
+}
 
-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);
+function isStatement(node
+/*: ESNode */
+)
+/*: node is Statement */
+{
+  return node.type === 'BlockStatement' || node.type === 'BreakStatement' || node.type === 'ClassDeclaration' || node.type === 'ContinueStatement' || node.type === 'DebuggerStatement' || node.type === 'DeclareClass' || node.type === 'DeclareVariable' || node.type === 'DeclareFunction' || node.type === 'DeclareInterface' || node.type === 'DeclareModule' || node.type === 'DeclareOpaqueType' || node.type === 'DeclareTypeAlias' || node.type === 'DoWhileStatement' || node.type === 'EmptyStatement' || node.type === 'EnumDeclaration' || node.type === 'ExpressionStatement' || node.type === 'ForInStatement' || node.type === 'ForOfStatement' || node.type === 'ForStatement' || node.type === 'FunctionDeclaration' || node.type === 'IfStatement' || node.type === 'InterfaceDeclaration' || node.type === 'LabeledStatement' || node.type === 'OpaqueType' || node.type === 'ReturnStatement' || node.type === 'SwitchStatement' || node.type === 'ThrowStatement' || node.type === 'TryStatement' || node.type === 'TypeAlias' || node.type === 'VariableDeclaration' || node.type === 'WhileStatement' || node.type === 'WithStatement';
 }

package/dist/predicates.js.flow

@@ -5,254 +5,200 @@
  * LICENSE file in the root directory of this source tree.
  *
  * @flow strict-local
- * @format
  */
 
 'use strict';
 
-import type {ESNode, Token} from './types';
-
-import {
-  isArrayExpression,
-  isArrowFunctionExpression,
-  isAsExpression,
-  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,
-  isNewExpression,
-  isObjectExpression,
-  isOpaqueType,
-  isProperty,
-  isPropertyDefinition,
-  isReturnStatement,
-  isSequenceExpression,
-  isSwitchStatement,
-  isTaggedTemplateExpression,
-  isTemplateLiteral,
-  isThisExpression,
-  isThrowStatement,
-  isTryStatement,
-  isTypeAlias,
-  isTypeCastExpression,
-  isUnaryExpression,
-  isUpdateExpression,
-  isVariableDeclaration,
-  isWhileStatement,
-  isWithStatement,
-  isYieldExpression,
-} from './generated/predicates';
+/*::
+import type {
+  ESNode,
+  Token,
+  MostTokens,
+  BlockComment,
+  LineComment,
+  AFunction,
+  PropertyDefinition,
+  PropertyDefinitionWithNonComputedName,
+  MethodDefinition,
+  MethodDefinitionConstructor,
+  MethodDefinitionWithNonComputedName,
+  MemberExpression,
+  MemberExpressionWithNonComputedName,
+  ObjectPropertyWithShorthandStaticName,
+  ObjectPropertyWithNonShorthandStaticName,
+  DestructuringObjectPropertyWithShorthandStaticName,
+  DestructuringObjectPropertyWithNonShorthandStaticName,
+  ClassMember,
+  ClassDeclaration,
+  ClassExpression,
+  Literal,
+  BigIntLiteral,
+  BooleanLiteral,
+  NullLiteral,
+  NumericLiteral,
+  RegExpLiteral,
+  StringLiteral,
+  Identifier,
+  EnumDefaultedMember,
+  Expression,
+  Statement,
+} from './types';
+*/
 
 export * from './generated/predicates';
 
-// $FlowFixMe[deprecated-type]
-export function isClass(node: ESNode): boolean %checks {
-  return isClassDeclaration(node) || isClassExpression(node);
+export function isClass(node /*: ESNode */) /*: node is (ClassDeclaration | ClassExpression) */ {
+  return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
 }
 
 export function isPropertyDefinitionWithNonComputedName(
-  node: ESNode,
-  // $FlowFixMe[deprecated-type]
-): boolean %checks {
-  return isPropertyDefinition(node) && node.computed === false;
+  node /*: ESNode */,
+) /*: node is PropertyDefinitionWithNonComputedName */ {
+  return node.type === 'PropertyDefinition' && node.computed === false;
 }
 
-// $FlowFixMe[deprecated-type]
-export function isClassMember(node: ESNode): boolean %checks {
-  return isPropertyDefinition(node) || isMethodDefinition(node);
+export function isClassMember(node /*: ESNode */) /*: node is ClassMember */ {
+  return node.type === 'PropertyDefinition' || node.type === 'MethodDefinition';
 }
 
 export function isClassMemberWithNonComputedName(
-  node: ESNode,
-  // $FlowFixMe[deprecated-type]
-): boolean %checks {
-  return isClassMember(node) && node.computed === false;
+  node /*: ESNode */,
+) /*: node is (PropertyDefinitionWithNonComputedName | MethodDefinitionConstructor | MethodDefinitionWithNonComputedName) */ {
+  return (node.type === 'PropertyDefinition' || node.type === 'MethodDefinition') && node.computed === false;
 }
 
-// $FlowFixMe[deprecated-type]
-export function isComment(node: ESNode | Token): boolean %checks {
-  return isBlockComment(node) || isLineComment(node);
+export function isComment(node /*: ESNode | Token */) /*: node is (MostTokens | BlockComment | LineComment) */ {
+  return node.type === 'Block' || node.type === 'Line';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isFunction(node: ESNode): boolean %checks {
+export function isFunction(node /*: ESNode */) /*: node is AFunction */ {
   return (
-    isArrowFunctionExpression(node) ||
-    isFunctionDeclaration(node) ||
-    isFunctionExpression(node)
+    node.type === 'ArrowFunctionExpression' ||
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression'
   );
 }
 
 export function isMethodDefinitionWithNonComputedName(
-  node: ESNode,
-  // $FlowFixMe[deprecated-type]
-): boolean %checks {
-  return isMethodDefinition(node) && node.computed === false;
+  node /*: ESNode */,
+) /*: node is (MethodDefinitionConstructor | MethodDefinitionWithNonComputedName) */ {
+  return node.type === 'MethodDefinition' && node.computed === false;
 }
 
 export function isMemberExpressionWithNonComputedProperty(
-  node: ESNode,
-  // $FlowFixMe[deprecated-type]
-): boolean %checks {
-  return isMemberExpression(node) && node.computed === false;
+  node /*: ESNode */,
+) /*: node is MemberExpressionWithNonComputedName */ {
+  return node.type === 'MemberExpression' && node.computed === false;
 }
 
 export function isOptionalMemberExpressionWithNonComputedProperty(
-  node: ESNode,
-  // $FlowFixMe[deprecated-type]
-): boolean %checks {
-  return isMemberExpression(node) && node.computed === false;
+  node /*: ESNode */,
+) /*: node is MemberExpressionWithNonComputedName */ {
+  return node.type === 'MemberExpression' && node.computed === false;
 }
 
-// $FlowFixMe[deprecated-type]
-export function isObjectPropertyWithShorthand(node: ESNode): boolean %checks {
-  return isProperty(node) && node.shorthand === true;
+export function isObjectPropertyWithShorthand(node /*: ESNode */) /*: node is (ObjectPropertyWithShorthandStaticName | DestructuringObjectPropertyWithShorthandStaticName) */ {
+  return node.type === 'Property' && node.shorthand === true;
 }
 
-export function isObjectPropertyWithNonComputedName(
-  node: ESNode,
-  // $FlowFixMe[deprecated-type]
-): boolean %checks {
-  return isProperty(node) && node.computed === false;
+export function isObjectPropertyWithNonComputedName(node /*: ESNode */) /*: node is (ObjectPropertyWithNonShorthandStaticName | ObjectPropertyWithShorthandStaticName | DestructuringObjectPropertyWithNonShorthandStaticName | DestructuringObjectPropertyWithShorthandStaticName) */ {
+  return node.type === 'Property' && node.computed === false;
 }
 
-// $FlowFixMe[deprecated-type]
-export function isBigIntLiteral(node: ESNode): boolean %checks {
-  return isLiteral(node) && node.literalType === 'bigint';
+export function isBigIntLiteral(node /*: ESNode */) /*: node is BigIntLiteral */ {
+  return node.type === 'Literal' && node.literalType === 'bigint';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isBooleanLiteral(node: ESNode): boolean %checks {
-  return isLiteral(node) && node.literalType === 'boolean';
+export function isBooleanLiteral(node /*: ESNode */) /*: node is BooleanLiteral */ {
+  return node.type === 'Literal' && node.literalType === 'boolean';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isNullLiteral(node: ESNode): boolean %checks {
-  return isLiteral(node) && node.literalType === 'null';
+export function isNullLiteral(node /*: ESNode */) /*: node is NullLiteral */ {
+  return node.type === 'Literal' && node.literalType === 'null';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isNumericLiteral(node: ESNode): boolean %checks {
-  return isLiteral(node) && node.literalType === 'numeric';
+export function isNumericLiteral(node /*: ESNode */) /*: node is NumericLiteral */ {
+  return node.type === 'Literal' && node.literalType === 'numeric';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isRegExpLiteral(node: ESNode): boolean %checks {
-  return isLiteral(node) && node.literalType === 'regexp';
+export function isRegExpLiteral(node /*: ESNode */) /*: node is RegExpLiteral */ {
+  return node.type === 'Literal' &&  node.literalType === 'regexp';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isStringLiteral(node: ESNode): boolean %checks {
-  return isLiteral(node) && node.literalType === 'string';
+export function isStringLiteral(node /*: ESNode */) /*: node is StringLiteral */ {
+  return node.type === 'Literal' && node.literalType === 'string';
 }
 
-// $FlowFixMe[deprecated-type]
-export function isExpression(node: ESNode): boolean %checks {
+export function isExpression(node /*: ESNode */) /*: node is Expression */ {
   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) ||
-    isAsExpression(node) ||
-    isJSXFragment(node) ||
-    isJSXElement(node)
+    node.type === 'ThisExpression' ||
+    node.type === 'ArrayExpression' ||
+    node.type === 'ObjectExpression' ||
+    // $FlowFixMe[incompatible-type]
+    node.type === 'ObjectExpression' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression' ||
+    node.type === 'YieldExpression' ||
+    node.type === 'Literal' ||
+    node.type === 'UnaryExpression' ||
+    node.type === 'UpdateExpression' ||
+    node.type === 'BinaryExpression' ||
+    node.type === 'AssignmentExpression' ||
+    node.type === 'LogicalExpression' ||
+    node.type === 'MemberExpression' ||
+    node.type === 'ConditionalExpression' ||
+    node.type === 'CallExpression' ||
+    node.type === 'NewExpression' ||
+    node.type === 'SequenceExpression' ||
+    node.type === 'TemplateLiteral' ||
+    node.type === 'TaggedTemplateExpression' ||
+    node.type === 'ClassExpression' ||
+    node.type === 'MetaProperty' ||
+    node.type === 'Identifier' ||
+    node.type === 'AwaitExpression' ||
+    node.type === 'ImportExpression' ||
+    node.type === 'ChainExpression' ||
+    node.type === 'TypeCastExpression' ||
+    node.type === 'AsExpression' ||
+    node.type === 'AsConstExpression' ||
+    node.type === 'JSXFragment' ||
+    node.type === 'JSXElement'
   );
 }
 
-// $FlowFixMe[deprecated-type]
-export function isStatement(node: ESNode): boolean %checks {
+export function isStatement(node /*: ESNode */) /*: node is Statement */ {
   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)
+    node.type === 'BlockStatement' ||
+    node.type === 'BreakStatement' ||
+    node.type === 'ClassDeclaration' ||
+    node.type === 'ContinueStatement' ||
+    node.type === 'DebuggerStatement' ||
+    node.type === 'DeclareClass' ||
+    node.type === 'DeclareVariable' ||
+    node.type === 'DeclareFunction' ||
+    node.type === 'DeclareInterface' ||
+    node.type === 'DeclareModule' ||
+    node.type === 'DeclareOpaqueType' ||
+    node.type === 'DeclareTypeAlias' ||
+    node.type === 'DoWhileStatement' ||
+    node.type === 'EmptyStatement' ||
+    node.type === 'EnumDeclaration' ||
+    node.type === 'ExpressionStatement' ||
+    node.type === 'ForInStatement' ||
+    node.type === 'ForOfStatement' ||
+    node.type === 'ForStatement' ||
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'IfStatement' ||
+    node.type === 'InterfaceDeclaration' ||
+    node.type === 'LabeledStatement' ||
+    node.type === 'OpaqueType' ||
+    node.type === 'ReturnStatement' ||
+    node.type === 'SwitchStatement' ||
+    node.type === 'ThrowStatement' ||
+    node.type === 'TryStatement' ||
+    node.type === 'TypeAlias' ||
+    node.type === 'VariableDeclaration' ||
+    node.type === 'WhileStatement' ||
+    node.type === 'WithStatement'
   );
 }

package/dist/types.js.flow

@@ -192,10 +192,12 @@ export type ESNode =
   | HookDeclaration
   | EnumDeclaration
   | EnumNumberBody
+  | EnumBigIntBody
   | EnumStringBody
   | EnumStringMember
   | EnumDefaultedMember
   | EnumNumberMember
+  | EnumBigIntMember
   | EnumBooleanBody
   | EnumBooleanMember
   | EnumSymbolBody
@@ -465,6 +467,7 @@ export type Expression =
   | ChainExpression
   | TypeCastExpression
   | AsExpression
+  | AsConstExpression
   | JSXFragment
   | JSXElement;
 
@@ -1286,6 +1289,7 @@ export interface KeyofTypeAnnotation extends BaseNode {
 export interface TupleTypeAnnotation extends BaseNode {
   +type: 'TupleTypeAnnotation';
   +types: $ReadOnlyArray<TypeAnnotationType>;
+  +inexact: boolean;
 }
 export interface TupleTypeSpreadElement extends BaseNode {
   +type: 'TupleTypeSpreadElement';
@@ -1369,7 +1373,7 @@ export interface TypePredicate extends BaseNode {
   +type: 'TypePredicate';
   +parameterName: Identifier;
   +typeAnnotation: TypeAnnotationType | null;
-  +asserts: boolean;
+  +kind: null | 'asserts' | 'implies';
 }
 
 export interface FunctionTypeAnnotation extends BaseNode {
@@ -1536,6 +1540,10 @@ export interface AsExpression extends BaseNode {
   +expression: Expression;
   +typeAnnotation: TypeAnnotationType;
 }
+export interface AsConstExpression extends BaseNode {
+  +type: 'AsConstExpression';
+  +expression: Expression;
+}
 
 interface BaseInterfaceNode extends BaseNode {
   +body: ObjectTypeAnnotation;
@@ -1552,7 +1560,7 @@ export interface InterfaceDeclaration extends BaseInterfaceDeclaration {
 
 export interface InterfaceExtends extends BaseNode {
   +type: 'InterfaceExtends';
-  +id: Identifier;
+  +id: Identifier | QualifiedTypeIdentifier;
   +typeParameters: null | TypeParameterInstantiation;
 
   +parent: InterfaceDeclaration | DeclareInterface;
@@ -1596,7 +1604,12 @@ export interface TypeParameterInstantiation extends BaseNode {
 export interface EnumDeclaration extends BaseNode {
   +type: 'EnumDeclaration';
   +id: Identifier;
-  +body: EnumNumberBody | EnumStringBody | EnumBooleanBody | EnumSymbolBody;
+  +body:
+    | EnumNumberBody
+    | EnumBigIntBody
+    | EnumStringBody
+    | EnumBooleanBody
+    | EnumSymbolBody;
 }
 
 interface BaseEnumBody extends BaseNode {
@@ -1623,6 +1636,23 @@ export interface EnumNumberMember extends BaseNode {
   +parent: EnumNumberBody;
 }
 
+export interface EnumBigIntBody extends BaseInferrableEnumBody {
+  +type: 'EnumBigIntBody';
+  // enum bigint members cannot be defaulted
+  +members: $ReadOnlyArray<EnumBigIntMember>;
+  +explicitType: boolean;
+
+  +parent: EnumDeclaration;
+}
+
+export interface EnumBigIntMember extends BaseNode {
+  +type: 'EnumBigIntMember';
+  +id: Identifier;
+  +init: BigIntLiteral;
+
+  +parent: EnumBigIntBody;
+}
+
 export interface EnumStringBody extends BaseInferrableEnumBody {
   +type: 'EnumStringBody';
   +members: $ReadOnlyArray<EnumStringMember | EnumDefaultedMember>;

package/package.json

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